{"text": "import sys\nsys.path.append('../rxnft_vae')\nimport rdkit\nimport rdkit.Chem as Chem\nfrom rdkit.Chem import QED, Descriptors, rdmolops\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport torch.optim.lr_scheduler as lr_scheduler\nfrom torch.utils.data import DataLoader\nfrom torch.autograd import Variable\n\nimport math, random, sys\nfrom optparse import OptionParser\nfrom collections import deque\n\nfrom reaction_utils import get_mol_from_smiles, get_smiles_from_mol,read_multistep_rxns, get_template_order, get_qed_score,get_clogp_score\nfrom reaction import ReactionTree, extract_starting_reactants, StartingReactants, Templates, extract_templates,stats\nfrom fragment import FragmentVocab, FragmentTree, FragmentNode, can_be_decomposed\nfrom vae import FTRXNVAE, set_batch_nodeID\nfrom mpn import MPN,PP,Discriminator\nfrom evaluate import Evaluator\nimport random\nimport numpy as np\nimport networkx as nx\n\nfrom sparse_gp import SparseGP\nimport scipy.stats as sps\nimport sascorer\n\n\ndef decode_many_times(model, latent):\n\tprob_decode = True\n\tlatent_size = model.latent_size\n\tft_mean = latent[:, :latent_size]\n\trxn_mean = latent[:, latent_size:]\n\tproduct_list=[]\n\tfor i in range(50):\n\t\tgenerated_tree = model.fragment_decoder.decode(ft_mean, prob_decode)\n\t\tg_encoder_output, g_root_vec = model.fragment_encoder([generated_tree])\n\t\tproduct, reactions = model.rxn_decoder.decode(rxn_mean, g_encoder_output, prob_decode)\n\t\tif product != None:\n\t\t\tproduct_list.append([product, reactions])\n\tif len(product_list) == 0:\n\t\treturn None\n\telse:\n\t\treturn product_list\n\ndef run_bo(X_train, y_train, X_test, y_test, model, parameters, metric, randseed):\n\trandom_seed = int(randseed)\n\tnp.random.seed(random_seed)\n\tif metric ==\"logp\":\n\t\tlogp_m = parameters[0]\n\t\tlogp_s = parameters[1]\n\t\tsascore_m = parameters[2]\n\t\tsascore_s = parameters[3]\n\t\tcycle_m = parameters[4]\n\t\tcycle_s = parameters[5]\n\n\tfilename = \"../Results/\" + metric + str(random_seed) + \".txt\"\n\n\t#print(\"maxmimum score :\", np.min(y_train), X_train.shape)\n\t#print(y_train)\n\twith open(filename, \"w\") as writer:\n\t\titeration = 0\n\t\tlatents = []\n\t\tmin_scores = []\n\t\twhile iteration < 5:\n\t\t\t# fit the GP\n\t\t\t#print(\"maxmimum score :\", np.min(y_train), X_train.shape)\n\t\t\tprint(iteration)\n\t\t\tnp.random.seed(iteration * random_seed)\n\t\t\tM = 500\n\t\t\tsgp = SparseGP(X_train, 0 * X_train, y_train, M)\n\t\t\tsgp.train_via_ADAM(X_train, 0 * X_train, y_train, X_test, X_test * 0, y_test, minibatch_size = 10 * M, max_iterations = 100, learning_rate = 0.001)\n\n\t\t\tpred, uncert = sgp.predict(X_test, 0 * X_test)\n\t\t\terror = np.sqrt(np.mean((pred - y_test)**2))\n\t\t\ttestll = np.mean(sps.norm.logpdf(pred - y_test, scale = np.sqrt(uncert)))\n\t\t\tprint('Test RMSE: ', error, ' Test ll: ', testll)\n\n\t\t\tpred, uncert = sgp.predict(X_train, 0 * X_train)\n\t\t\terror = np.sqrt(np.mean((pred - y_train)**2))\n\t\t\ttrainll = np.mean(sps.norm.logpdf(pred - y_train, scale = np.sqrt(uncert)))\n\t\t\tprint( 'Train RMSE: ', error, 'Train ll: ', trainll)\n\t\t\t#print( 'Train ll: ', trainll)\n\n\t\t\tnext_inputs, values = sgp.batched_greedy_ei(60, np.min(X_train, 0), np.max(X_train, 0))\n\t\t\tvalid_smiles =[]\n\t\t\tnew_features =[]\n\t\t\tfull_rxn_strs=[]\n\t\t\tvalues = values.flatten()\n\t\t\tfor i in range(60):\n\t\t\t\t#print(i)\n\t\t\t\tlatent = next_inputs[i].reshape((1,-1))\n\t\t\t\t#res = model.decode_many_times(torch.from_numpy(latent).float(), 50)\n\t\t\t\tres= decode_many_times(model, torch.from_numpy(latent).float())\n\t\t\t\tif res is not None:\n\t\t\t\t\tsmiles_list = [re[0] for re in res]\n\t\t\t\t\tn_reactions = [len(re[1].split(\" \")) for re in res]\n\t\t\t\t\t#print(n_reactions)\n\t\t\t\t\tfor re in res:\n\t\t\t\t\t\tsmiles = re[0]\n\t\t\t\t\t\tif len(re[1].split(\" \")) > 0 and smiles not in valid_smiles:\n\t\t\t\t\t\t\t#print(smiles, re[1].split(\" \"))\n\t\t\t\t\t\t\tvalid_smiles.append(smiles)\n\t\t\t\t\t\t\tnew_features.append(latent)\n\t\t\t\t\t\t\tfull_rxn_strs.append(re[1])\n\t\t\t\t#print(i, res)\n\t\t\t\t\t\n\t\t\t#new_features = np.vstack(new_features)\n\t\t\tscores =[]\n\t\t\tb_valid_smiles=[]\n\t\t\tb_full_rxn_strs=[]\n\t\t\tb_scores=[]\n\t\t\tb_new_features=[]\n\t\t\tfor i in range(len(valid_smiles)):\n\t\t\t\tif metric ==\"logp\":\n\t\t\t\t\tmol = rdkit.Chem.MolFromSmiles(valid_smiles[i])\n\t\t\t\t\tif mol is None:\n\t\t\t\t\t\tcontinue\n\t\t\t\t\tcurrent_log_P_value = Descriptors.MolLogP(mol)\n\t\t\t\t\tcurrent_SA_score = -sascorer.calculateScore(mol)\n\t\t\t\t\tcycle_list = nx.cycle_basis(nx.Graph(rdmolops.GetAdjacencyMatrix(mol)))\n\t\t\t\t\tif len(cycle_list) == 0:\n\t\t\t\t\t\tcycle_length = 0\n\t\t\t\t\telse:\n\t\t\t\t\t\tcycle_length = max([ len(j) for j in cycle_list ])\n\t\t\t\t\tif cycle_length <= 6:\n\t\t\t\t\t\tcycle_length = 0\n\t\t\t\t\telse:\n\t\t\t\t\t\tcycle_length = cycle_length - 6\n\t\t\t\t\tcurrent_cycle_score = -cycle_length\n\t\t\t\t\tcurrent_SA_score_normalized = (current_SA_score - sascore_m) / sascore_s\n\t\t\t\t\tcurrent_log_P_value_normalized = (current_log_P_value - logp_m) / logp_s\n\t\t\t\t\tcurrent_cycle_score_normalized = (current_cycle_score - cycle_m) / cycle_s\n\t\t\t\t\tscore = current_SA_score_normalized + current_log_P_value_normalized + current_cycle_score_normalized\n\t\t\t\t\tscores.append(-score)\n\t\t\t\t\tb_valid_smiles.append(valid_smiles[i])\n\t\t\t\t\tb_full_rxn_strs.append(full_rxn_strs[i])\n\t\t\t\t\tb_new_features.append(new_features[i])\n\t\t\t\tif metric==\"qed\":\n\t\t\t\t\tmol = rdkit.Chem.MolFromSmiles(valid_smiles[i])\n\t\t\t\t\tif mol!=None:\n\t\t\t\t\t\tscore = QED.qed(mol)\n\t\t\t\t\t\tscores.append(-score)\n\t\t\t\t\t\tb_valid_smiles.append(valid_smiles[i])\n\t\t\t\t\t\tb_full_rxn_strs.append(full_rxn_strs[i])\n\t\t\t\t\t\tb_new_features.append(new_features[i])\n\t\t\tnew_features = np.vstack(b_new_features)\n\t\t\tif len(new_features) > 0:\n\t\t\t\tX_train = np.concatenate([ X_train, new_features ], 0)\n\t\t\t\ty_train = np.concatenate([ y_train, np.array(scores)[ :, None ] ], 0)\n\t\t\titeration+=1\n\n\t\t\tfor i in range(len(b_valid_smiles)):\n\t\t\t\tline = \" \".join([b_valid_smiles[i], b_full_rxn_strs[i], str(scores[i])])\n\t\t\t\twriter.write(line + \"\\n\")\n\t\t\t#print(iteration, min(scores))\n\n\n\n\nparser = OptionParser()\nparser.add_option(\"-w\", \"--hidden\", dest=\"hidden_size\", default=200)\nparser.add_option(\"-l\", \"--latent\", dest=\"latent_size\", default=50)\nparser.add_option(\"-d\", \"--depth\", dest=\"depth\", default=2)\nparser.add_option(\"-s\", \"--save_dir\", dest=\"save_path\")\nparser.add_option(\"-t\", \"--data_path\", dest=\"data_path\")\nparser.add_option(\"-v\", \"--vocab_path\", dest=\"vocab_path\")\nparser.add_option(\"-m\", \"--metric\", dest=\"metric\")\nparser.add_option(\"-r\", \"--seed\", dest=\"seed\", default=1)\nopts, _ = parser.parse_args()\n\n# get parameters\nhidden_size = int(opts.hidden_size)\nlatent_size = int(opts.latent_size)\ndepth = int(opts.depth)\nvocab_path = opts.vocab_path\ndata_filename = opts.data_path\nw_save_path = opts.save_path\nmetric = opts.metric\nseed = int(opts.seed)\n\n\n# load model\nif torch.cuda.is_available():\n\t#device = torch.device(\"cuda:1\")\n\tdevice = torch.device(\"cuda\")\n\ttorch.cuda.set_device(1)\nelse:\n\tdevice = torch.device(\"cpu\")\n\n\nprint(\"hidden size:\", hidden_size, \"latent_size:\", latent_size, \"depth:\", depth)\nprint(\"loading data.....\")\ndata_filename = opts.data_path\nroutes, scores = read_multistep_rxns(data_filename)\nrxn_trees = [ReactionTree(route) for route in routes]\nmolecules = [rxn_tree.molecule_nodes[0].smiles for rxn_tree in rxn_trees]\nreactants = extract_starting_reactants(rxn_trees)\ntemplates, n_reacts = extract_templates(rxn_trees)\nreactantDic = StartingReactants(reactants)\ntemplateDic = Templates(templates, n_reacts)\n\nprint(\"size of reactant dic:\", reactantDic.size())\nprint(\"size of template dic:\", templateDic.size())\n\n\nn_pairs = len(routes)\nind_list = [i for i in range(n_pairs)]\nfgm_trees = [FragmentTree(rxn_trees[i].molecule_nodes[0].smiles) for i in ind_list]\nrxn_trees = [rxn_trees[i] for i in ind_list]\ndata_pairs=[]\nfor fgm_tree, rxn_tree in zip(fgm_trees, rxn_trees):\n\tdata_pairs.append((fgm_tree, rxn_tree))\ncset=set()\nfor fgm_tree in fgm_trees:\n\tfor node in fgm_tree.nodes:\n\t\tcset.add(node.smiles)\ncset = list(cset)\nif vocab_path is None:\n\tfragmentDic = FragmentVocab(cset)\nelse:\n\tfragmentDic = FragmentVocab(cset, filename =vocab_path)\n\nprint(\"size of fragment dic:\", fragmentDic.size())\n\n\n\n# loading model\n\nmpn = MPN(hidden_size, depth)\nmodel = FTRXNVAE(fragmentDic, reactantDic, templateDic, hidden_size, latent_size, depth, fragment_embedding=None, reactant_embedding=None, template_embedding=None)\ncheckpoint = torch.load(w_save_path, map_location=device)\nmodel.load_state_dict(checkpoint)\nprint(\"finished loading model...\")\n\nprint(\"number of samples:\", len(data_pairs))\nlatent_list=[]\nscore_list=[]\nprint(\"num of samples:\", len(rxn_trees))\nlatent_list =[]\nscore_list=[]\nif metric ==\"qed\":\n\tfor i, data_pair in enumerate(data_pairs):\n\t\tlatent = model.encode([data_pair])\n\t\t#print(i, latent.size(), latent)\n\t\tlatent_list.append(latent[0])\n\t\trxn_tree = data_pair[1]\n\t\tsmiles = rxn_tree.molecule_nodes[0].smiles\n\t\tscore_list.append(get_qed_score(smiles))\nif metric ==\"logp\":\n\tlogP_values = np.loadtxt('logP_values.txt')\n\tSA_scores = np.loadtxt('SA_scores.txt')\n\tcycle_scores = np.loadtxt('cycle_scores.txt')\n\n\tlogp_m = np.mean(logP_values)\n\tlogp_s = np.std(logP_values)\n\n\tsascore_m = np.mean(SA_scores)\n\tsascore_s = np.std(SA_scores)\n\n\tcycle_m = np.mean(cycle_scores)\n\tcycle_s = np.std(cycle_scores)\n\tfor i, data_pair in enumerate(data_pairs):\n\t\tlatent = model.encode([data_pair])\n\t\tlatent_list.append(latent[0])\n\t\trxn_tree = data_pair[1]\n\t\tsmiles = rxn_tree.molecule_nodes[0].smiles\n\t\tscore_list.append(get_clogp_score(smiles, logp_m, logp_s, sascore_m, sascore_s, cycle_m, cycle_s))\nlatents = torch.stack(latent_list, dim=0)\nscores = np.array(score_list)\nscores = scores.reshape((-1,1))\nlatents = latents.detach().numpy()\nn = latents.shape[0]\npermutation = np.random.choice(n, n, replace = False)\nX_train = latents[ permutation, : ][ 0 : np.int(np.round(0.9 * n)), : ]\nX_test = latents[ permutation, : ][ np.int(np.round(0.9 * n)) :, : ]\ny_train = -scores[ permutation ][ 0 : np.int(np.round(0.9 * n)) ]\ny_test = -scores[ permutation ][ np.int(np.round(0.9 * n)) : ]\nprint(X_train.shape, X_test.shape)\nif metric == \"logp\":\n\tparameters = [logp_m, logp_s, sascore_m, sascore_s, cycle_m, cycle_s]\nelse: \n\tparameters =[]\n\n\nrun_bo(X_train, y_train, X_test, y_test, model, parameters, metric, seed)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "1b9bf5f8e5a280fc98f029a2b09ebec9dfc3bf86", "size": 10018, "ext": "py", "lang": "Python", "max_stars_repo_path": "bo/run_bo.py", "max_stars_repo_name": "tsudalab/rxngenerator", "max_stars_repo_head_hexsha": "6f459828c03485926adb390e5bfbd4a6d91de30b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2022-01-04T09:36:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-03T22:35:53.000Z", "max_issues_repo_path": "bo/run_bo.py", "max_issues_repo_name": "tsudalab/rxngenerator", "max_issues_repo_head_hexsha": "6f459828c03485926adb390e5bfbd4a6d91de30b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "bo/run_bo.py", "max_forks_repo_name": "tsudalab/rxngenerator", "max_forks_repo_head_hexsha": "6f459828c03485926adb390e5bfbd4a6d91de30b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-12-17T19:17:44.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-17T19:17:44.000Z", "avg_line_length": 32.4207119741, "max_line_length": 163, "alphanum_fraction": 0.7180075863, "include": true, "reason": "import numpy,import scipy,import networkx", "num_tokens": 2825, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632683808533, "lm_q2_score": 0.18242551713899047, "lm_q1q2_score": 0.09903211247013974}}
{"text": "import pickle\nimport os\nimport time\nimport numpy as np\nimport sys\nimport shutil\nfrom openmmlib import openmmlib\nfrom openmmlib import polymerutils\nfrom openmmlib.polymerutils import scanBlocks\nfrom openmmlib.openmmlib import Simulation\nfrom openmmlib.polymerutils import grow_rw\nimport pyximport; pyximport.install()\nfrom smcTranslocator_MovingBarrier import smcTranslocatorDirectional\nimport tools\nimport random\n\n# -------defining parameters----------\n# -- basic loop extrusion parameters--\n\nlogname=\"log.txt\"\nGPU = 0 \nLIFETIME = 100   # Processivity of cohesin, Default: 100 for WT, 1000 for Wapl KO\nSEPARATION = 200 # Separation LEFs in number of monomers, Default: 200 for WT, 100 for Wapl KO, assuming a  monomer size of 1kb\nN = 10000                     # System size in number of monomers\nsmcStepsPerBlock = 1          # Number of LEF steps between blocks of polymer simulations, Default: 1\nstiff = 1                     # Polymer siffness in unit of bead size, default: 1\ndens = 0.2                    # density in beads / volume. The density can roughly be estimated by looking at the amount of DNA in a nuclear volume, Default: 0.2\nbox = (N / dens) ** 0.33      # Define size of the bounding box for Periodic Boundary Conditions, Default: 0.33\ndata = polymerutils.grow_rw(N, int(box) - 2)  # creates a compact conformation \nblock = 0  # starting block \nstg = 0.8# same as Banigan, van den Berg, Brandao eLife 2020 #0.1  #stall probability at ctcf sites \nunstallLEFRate = 0.005 # about once per two typical LEF lifetimes.\nctcf_interval = 300 # 300 kb, e.g., see Busslinger et al. Nature 2017\n\n# -- LEF and transcription dynamics -- \n\n# Note that the each rate can have a maximum value of 1. \nlef_speed=1.0\nlefperm = 0. # controls amount of LEF-LEF bypassing we have\npauseArray = np.ones(N,dtype=np.double) # The speed of LEFS at each position. Default is an array of ones, which means that LEFS go on maximum speed everywhere. To simulate the presence of CTCF Aafke reduced the speed at CTCF sites to 0.005. However, this doesn't account for directionality of CTCF!\nshrinkPauseArray=np.zeros(N,dtype=np.double)# speed at which loops shrink\nshrink_speed=0.0\nkinPol= 0.001     # PolII initiation rate, Default range: 0.00025-0.002\nkterPol=0.002                 # Termination rate of PolII, Default range: 0.002-1.0. Normally transcription is initiation limited, so make sure that kinPol < kterPol\nkterPolArray=np.zeros(N,dtype=np.double) # fix this later based on gene stucture\nPolSpeed=0.1                  # The speed of PolII as a fraction of the speed of cohesin. Default value: 0.1\npoldissoc=0.\n#pauseArrayPol=np.zeros(N,dtype=np.double) + PolSpeed # The speed of PolII at each lattice site #initialize later\npolloading=np.array([950,1950,2950,3950,4950,5950,6950,7950,8950]) # PolII initiation sites. The direction of the gene is set by the relative position of the polloading and poltermination sites.\n#np.array([700,903,1100,1303,1700,1903,2100,2303,2700,2903,3100,3303,3700,3903,4100,4303,4700,4903,5100,5303,5700,5903,6100,6303])\npoltermination=np.array([1850,2850,3850,4850,5850,6850,7850,8850,9850]) #PolII termination sites. At a termination site, PolII stalls with probability 1 and then unloads with rate kterPol. To simulate a broad PolII unloading area, I would set the poltermination site far beyond the gene length and then define wide region where PolII can stall, as shown on the lines below\n#np.array([800,803,1200,1203,1800,1803,2200,2203,2800,2803,3200,3203,3800,3803,4200,4203,4800,4803,5200,5203,5800,5803,6200,6203])\nstalProbPol=np.zeros(N,dtype=np.double) # The rate of PolII stalling. Once stalled, PolII unloads with a rate 'kterPol'. One can choose a single stall site, or a range of stall sites. If this array is set to zero everywhere, PolII will stall at the defined termination sites.\nstalProb=0.001                \nstall_in_gene=0.\nunstall_in_gene=1.\nunstallArray=np.zeros(N,dtype=np.double) #array for unstalling in of Pol II in gene\n\nSTALL_FROM_FILE = False # option to take stall probabilities from file for spatially varying patterns \nstallfile=\"\"\ngene_stall=[]\nctcf_left_list=[]\nctcf_right_list=[]\nstrongCTCFstall = 0\n\nTSSloadbias = 1.0\nTSSloadstart=0 #use this and TSSloadend to control offset/width of loading near TSS,  note: positive TSSloadstart denotes num sites before TSS, positive TSSloadend denotes sites after TSS\nTSSloadend=0\n\nbase_genelen=200\n#genelength=[base_genelen]*len(polloading)\nvariable_genelength = 0 \nfixed_variable_genelength=0\nvariable_permeability = 0 #This varaible toggles on/off variable permeability of cohesin through RNAp depending on position in gene, 0 or 1 for constant permeability or variable perm, respectively\nvariable_type = 0 #type of variable permeability: 0- linearly decreasing, 1- step function\nvariable_offset = 0 #param for var perm function: for linear this is a constant offset from 0, for step this is offset for the bottom step\nvariable_pos = base_genelen // 2 #param: irrelevant for linear, position of step for step function.\nvariable_return = 0 #return to max permeability after passing end of gene but before reaching termination site\nvariable_TSSfactor = 1.0  # factor by which permeability at TSS is lower (or higher)\n\npermLeftArray=np.zeros(N,dtype=np.double)\npermRightArray=np.zeros(N,dtype=np.double)\n\ncollisionLifeFactor=1.0 # factor by which head-on collision with RNAP changes lifetime of cohesin\ncollisionLife=LIFETIME*collisionLifeFactor\nTTSunload=1.0 # factor by which cohesin life time is changed near TTS\nunloadZone=10 # width of zone in which cohesin life is changed by TTS\n\nPolPause=0.002   # Step rate PolII at TSS, Default: 0.002\n#later:\n#for i in polloading:\n#    pauseArrayPol[i]=PolPause\n\nL=0.          # Set permeability of PolII to cohesin. L=0 means PolII is impermeable. \nR=0.          # Set permeability of PolII to cohesin coming from the right\n\nrun_id=1\n\n\n# -- polymer simulation settings --\n\nsteps = int(200*(smcStepsPerBlock)) # nr of 3D simulation blocks btw advancing LEFs. For deterministic stepping choose 200-250 steps per block, otherwise, rescale with stepping probability. When genes are sparse, smcStepsPerBLock is approximately the number of smc steps per smc block.\n\nsaveRNAP=True # whether or not to print RNAP positions w/ each printed block\n\nsaveEveryBlocks = int(200/(smcStepsPerBlock))  # number of blocks until polymer configuration is saved\nskipSavedBlocksBeginning = int(20/(smcStepsPerBlock))  # how many blocks (saved) to skip after you restart LEF positions\n#totalSavedBlocks = 5000  # how many blocks to save (number of blocks done is totalSavedBlocks * saveEveryBlocks)\ntotalSavedBlocks = 4000  # how many blocks to save (number of blocks done is totalSavedBlocks * saveEveryBlocks)\n#restartMilkerEveryBlocks = int(200/(smcStepsPerBlock))   \nrestartMilkerEveryBlocks = int(400/(smcStepsPerBlock))   \n#Only one Hamiltonian can be loaded at a time to the simkt, but we want to update the bonds every time a LEF steps. Loading a new Hamiltonian costs a lot of time. Instead we precalculate bonds and load all positions at once as one big Hamiltonian and just change the prefactors. \n\n# parameters for smc bonds \n\nsmcBondWiggleDist = 0.2\nsmcBondDist = 0.5\n\n\n#if len(sys.argv)!=8:\n#    print(\"Warning: Number of input arguments != 8\")\n#    sys.exit('Number of input arguments is not correct')\n\nFLAG=\"\" #extra label for directory name\n\n#######use custom class to parse inputs with keywords#######################\n\nparams= tools.argsList()\nfor p in params.arg_dict:\n    print(p, params.arg_dict[p])\n\nif \"gpu\" in params.arg_dict:\n    GPU = int(params.arg_dict[\"gpu\"])\nif \"lifetime\" in params.arg_dict:\n    LIFETIME = float(params.arg_dict[\"lifetime\"])\nif \"separation\" in params.arg_dict:\n    SEPARATION = float(params.arg_dict[\"separation\"])\nif \"initiation\" in params.arg_dict:\n    kinPol = float(params.arg_dict[\"initiation\"])\nif \"termination\" in params.arg_dict:\n    kterPol = float(params.arg_dict[\"termination\"])\nif \"dissociation\" in params.arg_dict:\n    poldissoc= float(params.arg_dict[\"dissociation\"])\nif \"stall\" in params.arg_dict: #pol stall\n    stalProb = float(params.arg_dict[\"stall\"])\nif \"stallgene\" in params.arg_dict:\n    stall_in_gene = float(params.arg_dict[\"stallgene\"])\nif \"unstall\" in params.arg_dict: # pol unstall\n    unstall_in_gene=float(params.arg_dict[\"unstall\"])\nif \"lefspeed\" in params.arg_dict:\n    lef_speed=float(params.arg_dict[\"lefspeed\"])\n    pauseArray= lef_speed*pauseArray\nif \"lefperm\" in params.arg_dict:\n    lefperm=float(params.arg_dict[\"lefperm\"])\nif \"shrink\" in params.arg_dict:\n    shrink_speed=float(params.arg_dict[\"shrink\"])\n    shrinkPauseArray= shrinkPauseArray + shrink_speed\n    if shrink_speed+lef_speed>1.:\n        print(\"WARNING: step+shrink > 1!! extrusion probabilities will not be computed correctly.\\n\")\nif \"lefstall\" in params.arg_dict:\n    stg = float(params.arg_dict[\"lefstall\"])\nif \"lefunstall\" in params.arg_dict:\n    unstallLEFRate = float(params.arg_dict[\"lefunstall\"])\nif \"polspeed\" in params.arg_dict:\n    PolSpeed = float(params.arg_dict[\"polspeed\"])\nif \"polpause\" in params.arg_dict:\n    PolPause = float(params.arg_dict[\"polpause\"])\nif \"permL\" in params.arg_dict:\n    L=float(params.arg_dict[\"permL\"])\nif \"permR\" in params.arg_dict:\n    R=float(params.arg_dict[\"permR\"])\nif \"collisionlife\" in params.arg_dict:\n    collisionLifeFactor=float(params.arg_dict[\"collisionlife\"])\nif \"tssload\" in params.arg_dict:\n    TSSloadbias=float(params.arg_dict[\"tssload\"])\nif \"tssloadstart\" in params.arg_dict:\n    TSSloadstart=int(params.arg_dict[\"tssloadstart\"])\nif \"tssloadend\" in params.arg_dict:\n    TSSloadend=int(params.arg_dict[\"tssloadend\"])\nif \"ttsunload\" in params.arg_dict:\n    TTSunload=float(params.arg_dict[\"ttsunload\"])\nif \"ttszone\" in params.arg_dict:\n    unloadZone=int(params.arg_dict[\"ttszone\"])\nif \"genelen\" in params.arg_dict:\n    base_genelen=int(params.arg_dict[\"genelen\"])\nif \"vperm\" in params.arg_dict:\n    variable_permeability = int(params.arg_dict[\"vperm\"])\nif \"vpermtype\" in params.arg_dict:\n    variable_type = int(params.arg_dict[\"vpermtype\"])\nif \"vpermoffset\" in params.arg_dict:\n    variable_offset = float(params.arg_dict[\"vpermoffset\"])\nif \"vpermpos\" in params.arg_dict:\n    variable_pos = int(params.arg_dict[\"vpermpos\"])\nif \"vreturn\" in params.arg_dict:\n    variable_return = int(params.arg_dict[\"vreturn\"])\nif \"vtss\" in params.arg_dict:\n    variable_TSSfactor = float(params.arg_dict[\"vtss\"])\nif \"vgene\" in params.arg_dict:\n    variable_genelength = int(params.arg_dict[\"vgene\"])\nif \"fixed_vgene\" in params.arg_dict:\n    fixed_variable_genelength=int(params.arg_dict[\"fixed_vgene\"])\nif \"convergent\" in params.arg_dict:\n    if int(params.arg_dict[\"convergent\"]):\n        #print(\"warning only correct for genelength = 110 right now.\\n\")\n        polloading=     np.array([840,  1160, 1640, 1960, 2440, 2760, 3240, 3560, 4040, 4360, 4840, 5160, 5640, 5960, 6440, 6760, 7240, 7560, 8040, 8360, 8840, 9160]) \n        poltermination= np.array([1000, 1001, 1800, 1801, 2600, 2601, 3400, 3401, 4200, 4201, 5000, 5001, 5800, 5801, 6600, 6601, 7400, 7401, 8200, 8201, 9000, 9001])\nif \"sparse\" in params.arg_dict:\n    if int(params.arg_dict[\"sparse\"]):\n        #print(\"warning only correct for genelength = 110 right now.\\n\")\n        polloading= np.array([1950,3950,5950,7950])\n        poltermination=np.array([2850,4850,6850,8850])\nif \"ctcfint\" in params.arg_dict:\n    ctcf_interval=int(params.arg_dict[\"ctcfint\"])\nif \"ctcf\" in params.arg_dict:\n    if params.arg_dict[\"ctcf\"] == \"tss\":\n        #puts ctcf just before each tss, alternating left/right \n        ctcf_left_list = polloading[0::2] - 1\n        ctcf_right_list = polloading[1::2] - 1\n    elif params.arg_dict[\"ctcf\"] == \"body\":\n        #puts ctcf halfway through the gene, assuming fixed gene length and genes pointing downstream\n        ctcf_left_list = polloading[0::2] + base_genelen // 2\n        ctcf_right_list = polloading[1::2] + base_genelen // 2\n    elif params.arg_dict[\"ctcf\"] == \"distributed\":\n        #put in sites every ~300 kb\n        Nctcf = int(N/ctcf_interval/2)\n        ctcf_left_list = np.arange(1,Nctcf+2)*2*ctcf_interval-ctcf_interval\n        ctcf_right_list = np.arange(1,Nctcf+1)*2*ctcf_interval\n        ctcf_left_list=np.delete(ctcf_left_list, np.where(ctcf_left_list>=N)[0])\n        ctcf_right_list=np.delete(ctcf_right_list, np.where(ctcf_right_list>=N)[0])\n    elif params.arg_dict[\"ctcf\"] == \"distributed2\":\n        Nctcf = int(N/ctcf_interval/2)\n        ctcf_left_list = np.arange(1,Nctcf+2)*2*ctcf_interval-int(3*ctcf_interval/2)\n        ctcf_right_list = np.arange(1,Nctcf+1)*2*ctcf_interval-int(ctcf_interval/2)\n        ctcf_left_list=np.delete(ctcf_left_list, np.where(ctcf_left_list>=N)[0])\n        ctcf_right_list=np.delete(ctcf_right_list, np.where(ctcf_right_list>=N)[0])\n    else:\n        with open(params.arg_dict[\"ctcf\"], \"r\") as ctcffile:\n            ctcfdata=ctcffile.readlines()\n            #should only be 2 lines\n            entries=ctcfdata[0].split()\n            ctcf_left_list = np.array([int(x) for x in entries])\n            entries=ctcfdata[1].split()\n            ctcf_right_list = np.array([int(x) for x in entries])\nif \"strongctcf\" in params.arg_dict:\n    strongCTCFstall= int(params.arg_dict[\"strongctcf\"])\n#granting command line control of these variables for flexibility:\nif \"save\" in params.arg_dict:\n    saveEveryBlocks = int(int(params.arg_dict[\"save\"])/(smcStepsPerBlock))\nif \"skip\" in params.arg_dict:\n    skipSavedBlocksBeginning = int(int(params.arg_dict[\"skip\"])/(smcStepsPerBlock))\nif \"total\" in params.arg_dict:\n    totalSavedBlocks = int(params.arg_dict[\"total\"])\nif \"stallfile\" in params.arg_dict:\n    stallfile=params.arg_dict[\"stallfile\"]\n    STALL_FROM_FILE=True\nif \"restart\" in params.arg_dict:\n    restartMilkerEveryBlocks = int(int(params.arg_dict[\"restart\"])/(smcStepsPerBlock))\nif \"log\" in params.arg_dict:\n    logname=params.arg_dict[\"log\"]\nif \"flag\" in params.arg_dict:\n    FLAG=params.arg_dict[\"flag\"]\n\n\n###### a few variables to be initialized last b/c they depend on others ###\ncollisionLife= LIFETIME*collisionLifeFactor\n\npauseArrayPol=np.zeros(N,dtype=np.double) + PolSpeed ## The speed of PolII at each lattice site\nfor i in polloading:\n    pauseArrayPol[i]=PolPause\n\ngenelength=[base_genelen]*len(polloading)\nif variable_genelength:\n    if fixed_variable_genelength:\n        genelength=random.shuffle([80,81,82,84,86,90,95,100,110])\n    else:\n        for ii in range(len(genelength)):\n            genelength[ii] = genelength[ii] + int(np.random.normal(0, np.sqrt(genelength[ii])))\n    print(\"genelengths:\", genelength)\n\n#stalling, unstalling and termination in gene and after gene ends\nfor i,j, gl in zip(polloading,poltermination, genelength):\n    if j>i: \n        stalProbPol[i:i+gl]=stall_in_gene \n        unstallArray[i:i+gl]=unstall_in_gene\n        stalProbPol[i+gl:j]=stalProb # This line adds stall probability to all sites between end of gene (loading site + gene len) and the \"termination site\" (where pol stops with prob=1) \n               # int(poltermination[0]-polloading[0])\n        kterPolArray[i+gl:j]=kterPol\n        kterPolArray[j]=kterPol\n    else: # flipped genes\n        stalProbPol[i-gl+1:i+1]=stall_in_gene\n        unstallArray[i-gl:i+1]=unstall_in_gene\n        stalProbPol[j+1:i-gl+1]=stalProb\n        kterPolArray[j+1:i-gl+1]=kterPol\n        kterPolArray[j]=kterPol\n\n\n#permeabilities\nif not variable_permeability:\n        permLeftArray += L\n        permRightArray += R\nelse:\n    for ii in range(len(genelength)):\n        direc = 2*int(poltermination[ii]>polloading[ii])-1\n        gene_end=genelength[ii]*direc+polloading[ii]\n        RL_factor=1.\n        if not L==0.:\n            RL_factor=R/L\n        if variable_type == 0:\n            for j in range(polloading[ii], gene_end):\n                permLeftArray[j] = L*(gene_end-j)/(gene_end-polloading[ii])*direc + variable_offset\n                permRightArray[j] = R*(gene_end-j)/(gene_end-polloading[ii])*direc + variable_offset*RL_factor\n            permLeftArray[polloading[ii]] *= variable_TSSfactor\n            permRightArray[polloading[ii]] *= variable_TSSfactor\n            if gene_end<poltermination[ii]:\n                s1=gene_end\n                s2=poltermination[ii]\n            else:\n                s1=poltermination[ii]+1\n                s2=gene_end+1\n            for j in range(s1,s2):\n                if not variable_return:\n                    permLeftArray[j] = variable_offset\n                    permRightArray[j] = variable_offset*RL_factor  # note that RL_factor adjusts right-left permeability of RNAP, not head-on/co-directional collision permeability. should change that. \n                else:\n                    permLeftArray[j] = L + variable_offset\n                    permRightArray[j] = R + variable_offset*RL_factor\n        elif variable_type == 1:\n            perm_break=polloading[ii]+direc*variable_pos\n            if polloading[ii] < perm_break:\n                s1=polloading[ii]\n                s2=perm_break\n            else:\n                s1=perm_break+1\n                s2=polloading[ii]+1\n            for j in range(s1,s2):\n                permLeftArray[j] = L\n                permRightArray[j] = R\n            permLeftArray[polloading[ii]] *= variable_TSSfactor\n            permRightArray[polloading[ii]] *= variable_TSSfactor\n            if perm_break<gene_end:\n                s1=perm_break\n                s2=gene_end\n            else:\n                s1=gene_end+1\n                s2=perm_break+1\n            for j in range(s1,s2):\n                permLeftArray[j] = variable_offset\n                permRightArray[j] = variable_offset*RL_factor\n            if gene_end<poltermination[ii]:\n                s1=gene_end\n                s2=poltermination[ii]\n            else:\n                s1=poltermination[ii]+1\n                s2=gene_end+1\n            for j in range(s1,s2):\n                if not variable_return:\n                    permLeftArray[j] = variable_offset\n                    permRightArray[j] = variable_offset*RL_factor\n                else:\n                    permLeftArray[j] = L\n                    permRightArray[j] = R\n\n# -- data folder -\nfolder=\"data/\"\n#folder = \"/net/levsha/scratch/ebanigan/txn/\"\n\n\nFullFileName=folder\nwhile True:\n    fname=\"extr_life{0}_sep{1}_density{2}_N{3}_kinpol{4}_kterPol{5}_TSSPause{6}_save{7}_total{8}_PSpeed{9}_stf{10}_stg{11}_th0.001_genelen{12}_stall{13}_L{14}_R{15}\".format(LIFETIME, SEPARATION, dens,N,kinPol,kterPol,PolPause,saveEveryBlocks,totalSavedBlocks,PolSpeed,stiff,stg,base_genelen,stalProb,L,R)\n    if variable_permeability:\n        fname=fname+\"_vperm\"+str(variable_type)+\"_offset\"+str(variable_offset)\n        if variable_type == 1:\n            fname=fname+\"_pos\"+str(variable_pos)\n        if variable_return == 1:\n            fname=fname+\"_vret\"\n        if not (variable_TSSfactor == 1.):\n            fname=fname+\"_vtss\"+str(variable_TSSfactor)\n    if not (TSSloadbias == 1.):\n        fname=fname+\"_tssload\"+str(TSSloadbias)\n        if not ((TSSloadstart==0) and (TSSloadend==0)):\n            fname=fname+\"_st{0}end{1}\".format(TSSloadstart,TSSloadend)\n    if variable_genelength:\n        fname=fname+\"_vgenelen\"\n    if not (collisionLifeFactor == 1.0):\n        fname=fname+\"_collife\"+str(collisionLife)\n    if not (TTSunload == 1.):\n        fname=fname+\"_ttslife\"+str(TTSunload*LIFETIME)+\"width\"+str(unloadZone)\n    if poldissoc > 0.:\n        fname=fname+\"_dissoc\"+str(poldissoc)\n    if lef_speed < 1.0:\n        fname=fname+\"_lefspeed\"+str(lef_speed)\n    if shrink_speed > 0.0:\n        fname=fname+\"_shrink\"+str(shrink_speed)\n    if stall_in_gene > 0.:\n        fname=fname+\"_stallgene{0}_unstall{1}\".format(stall_in_gene, unstall_in_gene)\n    if lefperm > 0.:\n        fname=fname+\"_lefperm{0}\".format(lefperm)\n    fname=fname+FLAG\n    fname=fname+\"_\"+str(run_id)\n    FullFileName=os.path.join(folder, fname) \n    sleeptime=np.random.uniform(0,10)\n    os.system(\"sleep {0}\".format(sleeptime))\n    if not os.path.exists(FullFileName):\n        os.system(\"mkdir {0}\".format(FullFileName))\n        print(\"directory is {0}\".format(FullFileName))\n        break\n    else:\n        run_id = run_id+1\n\n\n# -- Assertions to make sure parameters have been chosen correctly --\n\nassert restartMilkerEveryBlocks % saveEveryBlocks == 0 \nassert (skipSavedBlocksBeginning * saveEveryBlocks) % restartMilkerEveryBlocks == 0 \nassert (totalSavedBlocks * saveEveryBlocks) % restartMilkerEveryBlocks == 0 \nassert smcStepsPerBlock<6 # max number of steps per smc block should not be too large to prevent 'jerky' polymer motion\n\nsavesPerMilker = restartMilkerEveryBlocks // saveEveryBlocks\nmilkerInitsSkip = saveEveryBlocks * skipSavedBlocksBeginning  // restartMilkerEveryBlocks\nmilkerInitsTotal  = (totalSavedBlocks + skipSavedBlocksBeginning) * saveEveryBlocks // restartMilkerEveryBlocks\nprint(\"Milker will be initialized {0} times, first {1} will be skipped\".format(milkerInitsTotal, milkerInitsSkip))\n\n# create filenames for Ekin, Epot and time\n\nEkin_fname = os.path.join(FullFileName,'Ekin.txt')\nEpot_fname = os.path.join(FullFileName,'Epot.txt')\ntime_fname = os.path.join(FullFileName,'time.txt')\nPar_fname  = os.path.join(FullFileName,'Pars.txt')\n\n\ndef save_Es_ts_Rg():\n    with open(time_fname, \"a+\") as time_file:\n        time_file.write('%f\\n'%(a.state.getTime()/openmmlib.ps))\n    with open(Ekin_fname, \"a+\") as Ekin_file:\n        Ekin_file.write('%f\\n'%((a.state.getKineticEnergy())/a.N/a.kT))\n    with open(Epot_fname, \"a+\") as Epot_file:\n        Epot_file.write('%f\\n'%((a.state.getPotentialEnergy()) /a.N /a.kT))\n\nclass smcTranslocatorMilker(object):\n\n    def __init__(self, smcTransObject):\n        \"\"\"\n        :param smcTransObject: smc translocator object to work with\n        \"\"\"\n        self.smcObject = smcTransObject\n        self.allBonds = []\n\n    def setParams(self, activeParamDict, inactiveParamDict):\n        \"\"\"\n        A method to set parameters for bonds.\n        It is a separate method because you may want to have a Simulation object already existing\n\n        :param activeParamDict: a dict (argument:value) of addBond arguments for active bonds\n        :param inactiveParamDict:  a dict (argument:value) of addBond arguments for inactive bonds\n\n        \"\"\"\n        self.activeParamDict = activeParamDict\n        self.inactiveParamDict = inactiveParamDict\n\n\n    def setup(self, bondForce,  blocks = 100, smcStepsPerBlock = 1):\n        \"\"\"\n        A method that milks smcTranslocator object\n        and creates a set of unique bonds, etc.\n\n        :param bondForce: a bondforce object (new after simulation restart!)\n        :param blocks: number of blocks to precalculate\n        :param smcStepsPerBlock: number of smcTranslocator steps per block\n        :return:\n        \"\"\"\n\n\n        if len(self.allBonds) != 0:\n            raise ValueError(\"Not all bonds were used; {0} sets left\".format(len(self.allBonds)))\n\n        self.bondForce = bondForce\n\n        #precalculating all bonds\n        allBonds = []\n        for dummy in range(blocks):\n            self.smcObject.steps(smcStepsPerBlock)\n            left, right = self.smcObject.getSMCs()\n            bonds = [(int(i), int(j)) for i,j in zip(left, right)]\n            allBonds.append(bonds)\n\n        self.allBonds = allBonds\n        self.uniqueBonds = list(set(sum(allBonds, []))) # 'sum' preserves order and makes one long list with bonds, 'set' creates a set with left bonds from different time points ordered from small to large and eliminates two equal bonds (also if they were created by different LEFs at different times). List turns set into a list with unique bonds at different time points.\n\n        # adding forces and getting bond indices\n        self.bondInds = []\n        self.curBonds = allBonds.pop(0) # pop(0) removes and returns first list of bonds\n\n        for bond in self.uniqueBonds:\n            paramset = self.activeParamDict if (bond in self.curBonds) else self.inactiveParamDict\n            ind = bondForce.addBond(bond[0], bond[1], **paramset)\n            self.bondInds.append(ind)\n        self.bondToInd = {i:j for i,j in zip(self.uniqueBonds, self.bondInds)}\n        return self.curBonds,[]\n\n\n    def step(self, context, verbose=False):\n        \"\"\"\n        Update the bonds to the next step.\n        It sets bonds for you automatically!\n        :param context:  context\n        :return: (current bonds, previous step bonds); just for reference\n        \"\"\"\n        if len(self.allBonds) == 0:\n            raise ValueError(\"No bonds left to run; you should restart simulation and run setup  again\")\n\n        pastBonds = self.curBonds\n        self.curBonds = self.allBonds.pop(0)  # getting current bonds\n        bondsRemove = [i for i in pastBonds if i not in self.curBonds]\n        bondsAdd = [i for i in self.curBonds if i not in pastBonds]\n        bondsStay = [i for i in pastBonds if i in self.curBonds]\n        if verbose:\n            print(\"{0} bonds stay, {1} new bonds, {2} bonds removed\".format(len(bondsStay),\n                                                                            len(bondsAdd), len(bondsRemove)))\n        bondsToChange = bondsAdd + bondsRemove\n        bondsIsAdd = [True] * len(bondsAdd) + [False] * len(bondsRemove)\n        for bond, isAdd in zip(bondsToChange, bondsIsAdd):\n            ind = self.bondToInd[bond]\n            paramset = self.activeParamDict if isAdd else self.inactiveParamDict\n            self.bondForce.setBondParameters(ind, bond[0], bond[1], **paramset)  # actually updating bonds\n        self.bondForce.updateParametersInContext(context)  # now run this to update things in the context\n        return self.curBonds, pastBonds\n\n    def getRNAP(self):\n        return self.smcObject.getPolOccupied()\n\ndef initModel():    \n    birthArray = np.zeros(N,dtype=np.double) + 0.1\n    #birthArray[polloading] *= TSSloadbias\n    for nn, tt  in zip(polloading,poltermination):\n        #the following accounts for different gene directions:\n        if tt > nn:\n            loadbegin=min(max(nn-TSSloadstart,0), N) #max/min construction here ensures range will not exceed ends of polymer, noting that TSSloadstart can be + or -\n            loadend=max(min(nn+TSSloadend+1,N),0)\n        else:\n            loadbegin= min(max(nn-TSSloadend,0),N)\n            loadend= max(min(nn+TSSloadstart+1,N),0)\n        for jj in range(loadbegin,loadend):\n            birthArray[jj] *= TSSloadbias\n    deathArray = np.zeros(N, dtype=np.double) + 1. / (LIFETIME)\n    collisionDeathArray= np.zeros(N,dtype=np.double) + 1./collisionLife\n    if not (TTSunload==1.):\n        for nn,tt,gg in zip(polloading, poltermination, genelength):\n            if tt>nn:\n                zonebegin=nn+gg\n                zoneend=min(nn+gg+unloadZone,N)\n            else:\n                zonebegin= max(nn-gg+1-unloadZone,0)\n                zoneend= nn-gg+1\n            for jj in range(zonebegin, zoneend):\n                deathArray[jj] = 1./(TTSunload*LIFETIME)\n                collisionDeathArray[jj] =  1./(TTSunload*LIFETIME)\n\n    stallLeftArray = np.zeros(N, dtype=np.double) #stall prob for left LEF legs, i.e. CTCF sites that point rightward\n    stallRightArray = np.zeros(N, dtype=np.double)\n    if STALL_FROM_FILE: #read in stall rates from file; file should provide list of LEF stalling rates starting from the TSS, extending as long as the configuration of repeats permits\n        with open(\"stallfiles/\"+stallfile,\"r\") as infile:\n            stall_list = infile.readlines()\n        for entry in stall_list:\n            gene_stall.append(float(entry.split()[0]))\n        for nn,tt in zip(polloading,poltermination):\n            ii=0\n            if nn<tt:\n                gene_direc=1\n            else:\n                gene_direc=-1\n            for ii in range(len(gene_stall)):\n                stallLeftArray[nn+ii*gene_direc]=gene_stall[ii]\n                stallRightArray[nn+ii*gene_direc]=gene_stall[ii]\n    else: #stall rates set by stall params & CTCF position options\n        stallLeftArray[ctcf_left_list] = stg  \n        stallRightArray[ctcf_right_list] = stg\n\n    unstallLEFArray = np.ones(N, dtype=np.double) * unstallLEFRate # generally have a single unstall rate.  doesn't matter if non-stall sites have unstall>0, since there won't be stalls there anyway\n    stallDeathArray = np.zeros(N, dtype=np.double) + 1. / (LIFETIME) # unbinding rate during stall can be different, but we usually leave it the same \n    smcNum = int(N / SEPARATION)\n    curPos = 0\n        \n    SMCTran = smcTranslocatorDirectional(birthArray, deathArray, stallLeftArray, stallRightArray, unstallLEFArray, pauseArray, stallDeathArray, smcNum, \n                                         kinPol,kterPolArray,pauseArrayPol,shrinkPauseArray, polloading,poltermination, stalProbPol, unstallArray, \n                                         PolPermL=permLeftArray, PolPermR=permRightArray, collisionFalloffProb=collisionDeathArray, \n                                         poldissoc= poldissoc, \n                                         LefPerm=lefperm,\n                                         strongCTCF=strongCTCFstall\n                                        )  \n    return SMCTran\n\n\nSMCTran = initModel()  # defining actual smc translocator object \n\n\n\n# now polymer simulation code starts\n\n# ------------feed smcTran to the milker---\nSMCTran.steps(1000000)  # first steps to \"equilibrate\" SMC dynamics. If desired of course. \nmilker = smcTranslocatorMilker(SMCTran)   # now feed this thing to milker (do it once!)\n#--------- end new code ------------\n\nfor milkerCount in range(milkerInitsTotal):\n    doSave = milkerCount >= milkerInitsSkip\n    \n    # simulation parameters are defined below \n    a = Simulation(timestep=80, thermostat=0.001)#Collision rate in inverse picoseconds, low collistion rate means ballistic like motion, default in openmmpolymer is 0.001. Motion polymer is not diffusive, this is ok for statistical average,\n    #but not for dynamics of the polymer\n    a.setup(platform=\"CUDA\", PBC=True, PBCbox=[box, box, box], GPU=GPU, precision=\"mixed\")  # set up GPU here, PBC=Periodic Boundary Conditions. Default integrator is langevin with 300 K, friction coefficient of 1/ps, step size 0.002ps\n    a.saveFolder(FullFileName)\n    a.load(data)\n    a.addHarmonicPolymerBonds(wiggleDist=0.1) # WiggleDist controls distance at which energy of bond equals kT\n    if stiff > 0:\n        a.addGrosbergStiffness(stiff) # Chain stiffness is introduced by an angular potential U(theta)=stiff(1-cos(theta-Pi))\n    a.addPolynomialRepulsiveForce(trunc=1.5, radiusMult=1.05) #Polynomial repulsive potential between particles. Has value trunc=3.0 at zero, stays flat until 0.6-0.7 and then drops to zero. For attraction between a selective set of particles, use LeonardJones or addSelectiveSSWForce (see blocks.py or ask Johannes)\n    a.step = block\n\n    # ------------ initializing milker; adding bonds ---------\n    # copied from addBond\n    kbond = a.kbondScalingFactor / (smcBondWiggleDist ** 2)\n    bondDist = smcBondDist * a.length_scale\n\n    activeParams = {\"length\":bondDist,\"k\":kbond}\n    inactiveParams = {\"length\":bondDist, \"k\":0} \n    milker.setParams(activeParams, inactiveParams)\n     \n    # this step actually puts all bonds in and sets first bonds to be what they should be\n    milker.setup(bondForce=a.forceDict[\"HarmonicBondForce\"],\n                 blocks=restartMilkerEveryBlocks,   # default value; milk for 100 blocks\n                 smcStepsPerBlock=smcStepsPerBlock)  # \n    print(\"Restarting milker\")\n\n    a.doBlock(steps=steps, increment=False)  # do block for the first time with first set of bonds in\n    #print('done 1')\n    for i in range(restartMilkerEveryBlocks - 1):\n        #print(i)\n        curBonds, pastBonds = milker.step(a.context)  # this updates bonds. You can do something with bonds here\n        if i % saveEveryBlocks == (saveEveryBlocks - 2):  \n            a.doBlock(steps=steps, increment = doSave)\n            if doSave: \n                a.save()\n                pickle.dump(curBonds, open(os.path.join(a.folder, \"SMC{0}.dat\".format(a.step)),'wb'))\n                save_Es_ts_Rg() # save energies and time\n                if saveRNAP:\n                    pickle.dump(milker.getRNAP(), open(os.path.join(a.folder, \"RNAP{0}.dat\".format(a.step)), 'wb'))\n        else:\n            a.integrator.step(steps)  # do steps without getting the positions from the GPU (faster)\n\n    data = a.getData()  # save data and step, and delete the simulation\n    block = a.step\n    del a\n    \n    time.sleep(0.2)  # wait 200ms for sanity (to let garbage collector do its magic)\n\nwith open(Par_fname,\"a+\") as Parfile:\n    Parfile.write(\" tau=\"+str(LIFETIME)+\"\\n Separation=\"+str(SEPARATION)+\"\\n N=\"+str(N)+\"\\n smcStepsPerBlock=\"+str(smcStepsPerBlock)+\"\\n stiff=\"+str(stiff)+\"\\n dens=\"+str(dens)+\"\\n block=\"+str(block)+\"\\n  SaveEveryBlocks=\"+str(saveEveryBlocks)+\"\\n skipSavedBlocksBeginning=\"+str(skipSavedBlocksBeginning)+\"\\n totalSavedBlocks=\"+str(totalSavedBlocks)+\"\\n restartMilkerEveryBlocks=\"+str(restartMilkerEveryBlocks)+\"\\n smcBondWiggleDist=\"+str(smcBondWiggleDist)+\"\\n smcBondDist=\"+str(smcBondDist)+\"\\n SmcTimestep=1\\n NumMonos\"+str(N))\n\n\nos.system(\"mv {0} {1}\".format(logname, FullFileName))\n\n\n", "meta": {"hexsha": "ec373cdf3e896491732cd7aa93a7f421bd8ace21", "size": 33192, "ext": "py", "lang": "Python", "max_stars_repo_path": "simulations/SimulateMovingBarrier.py", "max_stars_repo_name": "mirnylab/moving-barriers-paper", "max_stars_repo_head_hexsha": "9084e0ce0725dfabaebcde89508b764e44b7662f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "simulations/SimulateMovingBarrier.py", "max_issues_repo_name": "mirnylab/moving-barriers-paper", "max_issues_repo_head_hexsha": "9084e0ce0725dfabaebcde89508b764e44b7662f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "simulations/SimulateMovingBarrier.py", "max_forks_repo_name": "mirnylab/moving-barriers-paper", "max_forks_repo_head_hexsha": "9084e0ce0725dfabaebcde89508b764e44b7662f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 49.9879518072, "max_line_length": 530, "alphanum_fraction": 0.6848638226, "include": true, "reason": "import numpy", "num_tokens": 9084, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.1919327841361473, "lm_q1q2_score": 0.09746574492847508}}
{"text": "# -*- coding: utf-8 -*-\n# ---\n# jupyter:\n#   jupytext:\n#     formats: ipynb,py,md\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.5'\n#       jupytext_version: 1.13.3\n#   kernelspec:\n#     display_name: Python 3 (ipykernel)\n#     language: python\n#     name: python3\n# ---\n\n# +\n# Uncomment to run the notebook in Colab\n# # ! pip install -q \"wax-ml[complete]@git+https://github.com/eserie/wax-ml.git\"\n# # ! pip install -q --upgrade jax jaxlib==0.1.70+cuda111 -f https://storage.googleapis.com/jax-releases/jax_releases.html\n# -\n\n# %matplotlib inline\n\n\nimport io\nimport warnings\nfrom collections import defaultdict\nfrom pathlib import Path\nfrom typing import Any, Callable, NamedTuple, Optional, TypeVar\n\nimport haiku as hk\nimport jax\nimport jax.numpy as jnp\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport numpy as onp\nimport optax\nimport pandas as pd\nimport plotnine as gg\nimport requests\nfrom sklearn.preprocessing import MinMaxScaler\nfrom tqdm.auto import tqdm\n\nfrom wax.accessors import register_wax_accessors\nfrom wax.compile import jit_init_apply\nfrom wax.encode import Encoder\nfrom wax.modules import Buffer, FillNanInf, Lag, RollingMean\nfrom wax.unroll import unroll\n\nprint(\"jax backend {}\".format(jax.lib.xla_bridge.get_backend().platform))\njax.devices()\n\n# # 🔭 Reconstructing the light curve of stars with LSTM 🔭\n#\n# [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/eserie/wax-ml/blob/main/docs/notebooks/05_reconstructing_the_light_curve_of_stars.ipynb)\n\n# Let's take a walk through the stars...\n#\n# This notebook is based on the study done in\n# [this post by Christophe Pere](https://towardsdatascience.com/how-to-use-deep-learning-for-time-series-forecasting-3f8a399cf205)\n# and the notebook available on\n# [the authors's github](https://github.com/Christophe-pere/Time_series_RNN).\n#\n# We will repeat this study on starlight using the LSTM architecture to predict the observed light flux through time.\n#\n# Our LSTM implementation is based on this [notebook from Haiku's github repository](https://github.com/deepmind/dm-haiku/blob/master/examples/haiku_lstms.ipynb).\n#\n# We'll see how to use WAX-ML to ease the preparation of time series data stored in dataframes and having Nans\n# before calling a \"standard\" deep-learning workflow.\n#\n# ## Disclaimer\n#\n# Despite the fact that this code works with real data, the results presented here should not be considered as scientific knowledge insights, to the knowledge of the authors of WAX-ML, neither the results nor the data source have been reviewed by an astrophysics pair.\n#\n# The purpose of this notebook is only to demonstrate how WAX-ML can be used when applying a \"standard\" machine learning workflow, here LSTM, to analyze time series.\n\n# ## Download the data\n\nregister_wax_accessors()\n\n# + tags=[\"parameters\"]\n# Parameters\nSTAR = \"007609553\"\nSEQ_LEN = 64\nBATCH_SIZE = 8\nTRAIN_SIZE = 2 ** 16\nNUM_EPOCHS = 10\nNUM_STARS = None\nRECORD_FREQ = 100\nTOTAL_LEN = None\nTRAIN_DATE = \"2016\"\nCACHE_DIR = Path(\"./cached_data/\")\n# -\n\n# %%time\nfilename = CACHE_DIR / \"kep_lightcurves.parquet\"\ntry:\n    raw_dataframe = pd.read_parquet(open(filename, \"rb\"))\n    print(f\"data read from {filename}\")\nexcept FileNotFoundError:\n    # Downloading the csv file from Chrustioge Pere GitHub account\n    download = requests.get(\n        \"https://raw.github.com/Christophe-pere/Time_series_RNN/master/kep_lightcurves.csv\"\n    ).content\n    raw_dataframe = pd.read_csv(io.StringIO(download.decode(\"utf-8\")))\n    # set date index\n    raw_dataframe.index = pd.Index(\n        pd.date_range(\"2009-03-07\", periods=len(raw_dataframe.index), freq=\"h\"),\n        name=\"time\",\n    )\n    # save dataframe locally in CACHE_DIR\n    CACHE_DIR.mkdir(exist_ok=True)\n    raw_dataframe.to_parquet(filename)\n    print(f\"data saved in {filename}\")\n\n\n# shortening of data to speed up the execution of the notebook in the CI\nif TOTAL_LEN:\n    raw_dataframe = raw_dataframe.iloc[:TOTAL_LEN]\n\n\n# Let's visualize the description of this dataset:\n\nraw_dataframe.describe().T.to_xarray()\n\n\nstars = raw_dataframe.columns\nstars = sorted(list(set([i.split(\"_\")[0] for i in stars])))\nprint(f\"The number of stars available is: {len(stars)}\")\nprint(f\"star identifiers: {stars}\")\n\ndataframe = raw_dataframe[[i + \"_rscl\" for i in stars]].rename(\n    columns=lambda c: c.replace(\"_rscl\", \"\")\n)\ndataframe.columns.names = [\"star\"]\ndataframe.shape\n\nif NUM_STARS:\n    columns = dataframe.columns.tolist()\n    columns.remove(STAR)\n    dataframe = dataframe[[STAR] + columns[: NUM_STARS - 1]]\n\n# ## Rolling mean\n\n# We will smooth the data by applying a rolling mean with a window of 100 periods.\n\n# ### Count nan values\n#\n# But before since the dataset has some nan values, we will extract few statistics\n# about the density of nan values in windows of size 100.\n#\n# It will be the occasion to show a usage of the `wax.modules.Buffer` module with the `format_outputs=False`\n# option for the dataframe accessor `.wax.stream`.\n\n\n# Let's apply the `Buffer` module to the data:\n\nbuffer, _ = dataframe.wax.stream(format_outputs=False).apply(lambda x: Buffer(100)(x))\n\nassert isinstance(buffer, jnp.ndarray)\n\n# Equivalently, we can use wax `unroll` function.\n\n\nbuffer = unroll(lambda x: Buffer(100)(x))(jax.device_put(dataframe.values))\n\n# Let's describe the statistic of nans with pandas:\n\ncount_nan = jnp.isnan(buffer).sum(axis=1)\npd.DataFrame(onp.array(count_nan)).stack().describe().astype(int)\n\n# ### Computing the rolling mean\n\n# We will choose a `min_periods` of 5 in order to keep at leas 75% of the points.\n\n# %%time\ndataframe_mean, _ = dataframe.wax.stream().apply(\n    lambda x: RollingMean(100, min_periods=5)(x)\n)\n\ndataframe.iloc[:, :2].plot()\n\n# ## Forecasting with Machine Learning\n#\n# We need two forecast in this data, if you look with attention you'll see micro holes and big holes.\n\n\nT = TypeVar(\"T\")\n\n\nclass Pair(NamedTuple):\n    x: T\n    y: T\n\n\nclass TrainSplit(NamedTuple):\n    train: T\n    validation: T\n\n\ngg.theme_set(gg.theme_bw())\nwarnings.filterwarnings(\"ignore\")\n\n\nplt.rcParams[\"figure.figsize\"] = 18, 8\nfig, (ax, lax) = plt.subplots(ncols=2, gridspec_kw={\"width_ratios\": [4, 1]})\ndataframe.plot(ax=ax, title=\"raw data\")\nax.legend(bbox_to_anchor=(0, 0, 1, 1), bbox_transform=lax.transAxes)\nlax.axis(\"off\")\n\n\nplt.rcParams[\"figure.figsize\"] = 18, 8\nfig, (ax, lax) = plt.subplots(ncols=2, gridspec_kw={\"width_ratios\": [4, 1]})\ndataframe_mean.plot(ax=ax, title=\"Smoothed data\")\nax.legend(bbox_to_anchor=(0, 0, 1, 1), bbox_transform=lax.transAxes)\nlax.axis(\"off\")\n# -\n\n# ### Normalize data\n\ndataframe_mean.stack().hist(bins=100, log=True)\n\n\ndef min_max_scaler(values: pd.DataFrame, output_format: str = \"dataframe\") -> Encoder:\n    scaler = MinMaxScaler(feature_range=(0, 1))\n    scaler.fit(values)\n    index = values.index\n    columns = values.columns\n\n    def encode(dataframe: pd.DataFrame):\n        nonlocal index\n        nonlocal columns\n\n        index = dataframe.index\n        columns = dataframe.columns\n        array_normed = scaler.transform(dataframe)\n\n        if output_format == \"dataframe\":\n            return pd.DataFrame(array_normed, index, columns)\n        elif output_format == \"jax\":\n            return jnp.array(array_normed)\n        else:\n            return array_normed\n\n    def decode(array_scaled):\n\n        value = scaler.inverse_transform(array_scaled)\n\n        if output_format == \"dataframe\":\n            return pd.DataFrame(value, index, columns)\n        else:\n            return value\n\n    return Encoder(encode, decode)\n\n\n# -\n\nscaler = min_max_scaler(dataframe_mean)\ndataframe_normed = scaler.encode(dataframe_mean)\nassert (scaler.decode(dataframe_normed) - dataframe_mean).stack().abs().max() < 1.0e-4\n\ndataframe_normed.stack().hist(bins=100)\n\n# ### Prepare train / validation datasets\n\n\ndef split_feature_target(\n    dataframe,\n    look_back=SEQ_LEN,\n    shuffle=True,\n    stack=True,\n    min_periods_ratio: float = 0.8,\n    rng=None,\n) -> Pair:\n    def prepare_xy(data):\n        buffer = Buffer(look_back + 1)(data)\n        x = buffer[:-1]\n        y = buffer[-1]\n        return x, y\n\n    def prepare_xy(data):\n        y = Buffer(look_back)(data)\n        x = Lag(1)(y)\n        return x, y\n\n    x, y = unroll(prepare_xy)(jax.device_put(dataframe.values))\n\n    if shuffle:\n        if rng is None:\n            rng = jax.random.PRNGKey(42)\n\n        B = x.shape[0]\n        idx = jnp.arange(B)\n        idx = jax.random.shuffle(rng, idx)\n\n        x = x[idx]\n        y = y[idx]\n\n    if stack:\n        B, T, F = x.shape\n        x = x.transpose(1, 0, 2).reshape(T, B * F, 1).transpose(1, 0, 2)\n        y = y.transpose(1, 0, 2).reshape(T, B * F, 1).transpose(1, 0, 2)\n\n    if min_periods_ratio:\n        T = x.shape[1]\n        count_nan = jnp.isnan(x).sum(axis=1)\n        mask = count_nan < min_periods_ratio * T\n        idx = jnp.where(mask)\n        x = x[idx[0]]\n        y = y[idx[0]]\n\n    # round Batch size to a power of to\n    B = x.shape[0]\n    B_round = int(2 ** jnp.floor(jnp.log2(B)))\n    print(f\"{B} batches rounded to {B_round} batches.\")\n    x = x[:B_round]\n    y = y[:B_round]\n\n    # fillnan by zeros\n    x, y = hk.testing.transform_and_run(lambda x: FillNanInf()(x))((x, y))\n\n    return Pair(x, y)\n\n\n# +\n# split_feature_target(dataframe)\n# -\n\n\ndef split_train_validation(\n    dataframe, train_size, look_back, scaler: Optional[Callable] = None\n) -> TrainSplit:\n\n    # prepare scaler\n    train_df = dataframe.iloc[:train_size]\n\n    if scaler:\n        scaler = scaler(train_df)\n\n    # prepare train data\n    if scaler:\n        train_df = scaler.encode(train_df)\n\n    train_xy = split_feature_target(train_df, look_back)\n\n    # prepare validation data\n    valid_size = len(dataframe) - train_size\n    valid_size = int(2 ** jnp.floor(jnp.log2(valid_size)))\n\n    valid_end = int(train_size + valid_size)\n    valid_df = dataframe.iloc[train_size:valid_end]\n\n    if scaler:\n        valid_df = scaler.encode(valid_df)\n\n    valid_xy = split_feature_target(valid_df, look_back)\n\n    return TrainSplit(train_xy, valid_xy)\n\n\nTRAIN_SIZE\n\nprint(f\"Look at star: {STAR}\")\ntrain, valid = split_train_validation(dataframe_normed[[STAR]], TRAIN_SIZE, SEQ_LEN)\n\ntrain[0].shape, train[1].shape, valid[0].shape, valid[1].shape\n\n# TRAIN_SIZE, VALID_SIZE = len(train.x), len(valid.x)\nprint(\n    f\"effective train_size = {len(train.x)}, \" f\"effective valid size= {len(valid.x)}\"\n)\n\n\n# Plot an observation/target pair.\nrng = jax.random.PRNGKey(42)\nbatch_plot = jax.random.choice(rng, len(train[0]))\ndf = pd.DataFrame(\n    {\"x\": train.x[batch_plot, :, 0], \"y\": train.y[batch_plot, :, 0]}\n).reset_index()\ndf = pd.melt(df, id_vars=[\"index\"], value_vars=[\"x\", \"y\"])\nplot = (\n    gg.ggplot(df)\n    + gg.aes(x=\"index\", y=\"value\", color=\"variable\")\n    + gg.geom_line()\n    + gg.scales.scale_y_log10()\n)\n_ = plot.draw()\n\n\n# ### Dataset iterator\n\n\nclass Dataset:\n    \"\"\"An iterator over a numpy array, revealing batch_size elements at a time.\"\"\"\n\n    def __init__(self, xy: Pair, batch_size: int):\n        self._x, self._y = xy\n        self._batch_size = batch_size\n        self._length = self._x.shape[0]\n        self._idx = 0\n        if self._length % batch_size != 0:\n            msg = \"dataset size {} must be divisible by batch_size {}.\"\n            raise ValueError(msg.format(self._length, batch_size))\n\n    def __next__(self) -> Pair:\n        start = self._idx\n        end = start + self._batch_size\n        x, y = self._x[start:end], self._y[start:end]\n        if end >= self._length:\n            print(f\"End of the data set (size={end}). Return to the beginning.\")\n            end = end % self._length\n            assert end == 0  # Guaranteed by ctor assertion.\n        self._idx = end\n        return Pair(x, y)\n\n\n# + [markdown] colab_type=\"text\" id=\"LZGw5Jdvjmqh\"\n# ### Training an LSTM\n#\n# To train the LSTM, we define a Haiku function which unrolls the LSTM over the input sequence, generating predictions for all output values. The LSTM always starts with its initial state at the start of the sequence.\n#\n# The Haiku function is then transformed into a pure function through `hk.transform`, and is trained with Adam on an L2 prediction loss.\n\n\n# + colab={} colab_type=\"code\" id=\"nacnTj5ejIK5\"\ndef unroll_net(seqs: jnp.ndarray):\n    \"\"\"Unrolls an LSTM over seqs, mapping each output to a scalar.\"\"\"\n    # seqs is [T, B, F].\n    core = hk.LSTM(32)\n    batch_size = seqs.shape[0]\n    outs, state = hk.dynamic_unroll(\n        core, seqs, core.initial_state(batch_size), time_major=False\n    )\n    # We could include this Linear as part of the recurrent core!\n    # However, it's more efficient on modern accelerators to run the linear once\n    # over the entire sequence than once per sequence element.\n    return hk.BatchApply(hk.Linear(1))(outs), state\n\n\n# + colab={} colab_type=\"code\" id=\"nacnTj5ejIK5\"\nmodel = jit_init_apply(hk.transform(unroll_net))\n\n\n# +\n@jax.jit\ndef loss(pred, y):\n    return jnp.mean(jnp.square(pred - y))\n\n\ndef model_with_loss(x, y):\n    pred, _ = unroll_net(x)\n    return loss(pred, y)\n\n\n# + colab={} colab_type=\"code\" id=\"nacnTj5ejIK5\"\nclass TrainState(NamedTuple):\n    step: int\n    params: Any\n    opt_state: Any\n    rng: jnp.ndarray\n    loss: float\n\n\ndef train_model(\n    model_with_loss: Callable,\n    train_ds: Dataset,\n    valid_ds: Dataset,\n    max_iterations: int = -1,\n    rng=None,\n    record_freq=100,\n) -> hk.Params:\n    \"\"\"Initializes and trains a model on train_ds, returning the final params.\"\"\"\n    opt = optax.adam(1e-3)\n    model_with_loss = jit_init_apply(hk.transform(model_with_loss))\n\n    @jax.jit\n    def update(train_state, x, y):\n        step, params, opt_state, rng, _ = train_state\n        if rng is not None:\n            (rng,) = jax.random.split(rng, 1)\n        l, grads = jax.value_and_grad(model_with_loss.apply)(params, rng, x, y)\n        grads, opt_state = opt.update(grads, opt_state)\n        params = optax.apply_updates(params, grads)\n        return TrainState(step + 1, params, opt_state, rng, l)\n\n    # Initialize state.\n    def init():\n        x, y = next(train_ds)\n        params = model_with_loss.init(rng, x, y)\n        opt_state = opt.init(params)\n        return TrainState(0, params, opt_state, rng, jnp.inf)\n\n    def _format_results(records):\n        records = {key: jnp.stack(l) for key, l in records.items()}\n        return records\n\n    records = defaultdict(list)\n    train_state = init()\n    with tqdm(total=max_iterations if max_iterations > 0 else None) as pbar:\n        while True:\n            try:\n                x, y = next(train_ds)\n            except StopIteration:\n                return train_state, _format_results(records)\n\n            train_state = update(train_state, x, y)\n            if train_state.step % record_freq == 0:\n                x, y = next(valid_ds)\n                if rng is not None:\n                    (rng,) = jax.random.split(rng, 1)\n                valid_loss = model_with_loss.apply(train_state.params, rng, x, y)\n                records[\"step\"].append(train_state.step)\n                records[\"valid_loss\"].append(valid_loss)\n                records[\"train_loss\"].append(train_state.loss)\n\n            pbar.update()\n            if max_iterations > 0 and train_state.step >= max_iterations:\n                return train_state, _format_results(records)\n\n\n# + colab={} colab_type=\"code\" id=\"AssgDctokbl5\"\n# %%time\ntrain, valid = split_train_validation(dataframe_normed[[STAR]], TRAIN_SIZE, SEQ_LEN)\ntrain_ds = Dataset(train, BATCH_SIZE)\nvalid_ds = Dataset(valid, BATCH_SIZE)\n\n\ntrain_state, records = train_model(\n    model_with_loss,\n    train_ds,\n    valid_ds,\n    len(train.x) // BATCH_SIZE * NUM_EPOCHS,\n    rng=jax.random.PRNGKey(42),\n    record_freq=RECORD_FREQ,\n)\n\n# +\n# train_state.params\n# -\n\n# Plot losses\nlosses = pd.DataFrame(records)\ndf = pd.melt(losses, id_vars=[\"step\"], value_vars=[\"train_loss\", \"valid_loss\"])\nplot = (\n    gg.ggplot(df)\n    + gg.aes(x=\"step\", y=\"value\", color=\"variable\")\n    + gg.geom_line()\n    + gg.scales.scale_y_log10()\n)\n_ = plot.draw()\n\n\n# + [markdown] colab_type=\"text\" id=\"yr7jrOL3ki-b\"\n# ### Sampling\n#\n# The point of training models is so that they can make predictions! How can we generate predictions with the trained model?\n#\n# If we're allowed to feed in the ground truth, we can just run the original model's `apply` function.\n\n# + colab={} colab_type=\"code\" id=\"f2qETEqXLT1N\"\ndef plot_samples(truth: np.ndarray, prediction: np.ndarray) -> gg.ggplot:\n    assert truth.shape == prediction.shape\n    df = pd.DataFrame(\n        {\"truth\": truth.squeeze(), \"predicted\": prediction.squeeze()}\n    ).reset_index()\n    df = pd.melt(df, id_vars=[\"index\"], value_vars=[\"truth\", \"predicted\"])\n    plot = (\n        gg.ggplot(df) + gg.aes(x=\"index\", y=\"value\", color=\"variable\") + gg.geom_line()\n    )\n    return plot\n\n\n# + colab={} colab_type=\"code\" id=\"KOuK1egilGD0\"\n# Grab a sample from the validation set.\nsample_x, sample_y = next(valid_ds)\nsample_x = sample_x[:1]  # Shrink to batch-size 1.\nsample_y = sample_y[:1]\n\n# Generate a prediction, feeding in ground truth at each point as input.\npredicted, _ = model.apply(train_state.params, None, sample_x)\n\nplot = plot_samples(sample_y, predicted)\nplot.draw()\ndel sample_x, predicted\n\n\n# -\n\n# ### Run autoregressively\n\n# + [markdown] colab_type=\"text\" id=\"tDyGshz_lwrM\"\n# If we can't feed in the ground truth (because we don't have it), we can also run the model autoregressively.\n\n# + colab={} colab_type=\"code\" id=\"Cg8oQ75Ulvld\"\ndef autoregressive_predict(\n    trained_params: hk.Params,\n    context: jnp.ndarray,\n    seq_len: int,\n    pbar=False,\n):\n    \"\"\"Given a context, autoregressively generate the rest of a sine wave.\"\"\"\n\n    ar_outs = []\n    context = jax.device_put(context)\n    times = onp.arange(seq_len - context.shape[1] + 1)\n    if pbar:\n        times = tqdm(times)\n    for _ in times:\n        full_context = jnp.concatenate([context] + ar_outs, axis=1)\n\n        outs, _ = model.apply(trained_params, None, full_context)\n        # Append the newest prediction to ar_outs.\n        ar_outs.append(outs[:, -1:, :])\n    # Return the final full prediction.\n    return outs\n\n\n# + colab={} colab_type=\"code\" id=\"Cg8oQ75Ulvld\"\nsample_x, sample_y = next(valid_ds)\nsample_x = sample_x[:1]  # Shrink to batch-size 1.\nsample_y = sample_y[:1]  # Shrink to batch-size 1.\n\n\ncontext_length = SEQ_LEN // 8\nprint(f\"context_length = {context_length}\")\n# Cut the batch-size 1 context from the start of the sequence.\ncontext = sample_x[:, :context_length]\n\n# + colab={} colab_type=\"code\" id=\"Cg8oQ75Ulvld\"\n# %%time\n# We can reuse params we got from training for inference - as long as the\n# declaration order is the same.\npredicted = autoregressive_predict(train_state.params, context, SEQ_LEN, pbar=True)\n# -\n\nsample_y.shape, predicted.shape\n\n# + colab={} colab_type=\"code\" id=\"Cg8oQ75Ulvld\"\nplot = plot_samples(sample_y, predicted)\nplot += gg.geom_vline(xintercept=context.shape[1], linetype=\"dashed\")\n_ = plot.draw()\n\n\n# + [markdown] colab_type=\"text\" id=\"qGkr2gf2oALo\"\n# #### Sharing parameters with a different function.\n#\n# Unfortunately, this is a bit slow - we're doing O(N^2) computation for a sequence of length N.\n#\n# It'd be better if we could do the autoregressive sampling all at once - but we need to write a new Haiku function for that.\n#\n# We're in luck - if the Haiku module names match, the same parameters can be used for multiple Haiku functions.\n#\n# This can be achieved through a combination of two techniques:\n#\n# 1. If we manually give a unique name to a module, we can ensure that the parameters are directed to the right places.\n# 2. If modules are instantiated in the same order, they'll have the same names in different functions.\n#\n# Here, we rely on method #2 to create a fast autoregressive prediction.\n\n# + colab_type=\"text\" id=\"qGkr2gf2oALo\"\n@hk.transform\ndef fast_autoregressive_predict_fn(context, seq_len):\n    \"\"\"Given a context, autoregressively generate the rest of a sine wave.\"\"\"\n    core = hk.LSTM(32)\n    dense = hk.Linear(1)\n    state = core.initial_state(context.shape[0])\n    # Unroll over the context using `hk.dynamic_unroll`.\n    # As before, we `hk.BatchApply` the Linear for efficiency.\n    context_outs, state = hk.dynamic_unroll(\n        core,\n        context,\n        state,\n        time_major=False,\n    )\n    context_outs = hk.BatchApply(dense)(context_outs)\n\n    # Now, unroll one step at a time using the running recurrent state.\n    ar_outs = []\n    x = context_outs[:, -1, :]\n    times = range(seq_len - context.shape[1])\n    for _ in times:\n        x, state = core(x, state)\n        x = dense(x)\n        ar_outs.append(x)\n    ar_outs = jnp.stack(ar_outs)\n    ar_outs = ar_outs.transpose(1, 0, 2)\n    return jnp.concatenate([context_outs, ar_outs], axis=1)\n\n\nfast_autoregressive_predict = jax.jit(\n    fast_autoregressive_predict_fn.apply, static_argnums=(3,)\n)\n\n# + colab={} colab_type=\"code\" id=\"WdKcHr6_n_ba\"\n# %%time\n# Reuse the same context from the previous cell.\npredicted = fast_autoregressive_predict(train_state.params, None, context, SEQ_LEN)\n\n\n# + colab={} colab_type=\"code\" id=\"WdKcHr6_n_ba\"\n# The plots should be equivalent!\nplot = plot_samples(sample_y, predicted)\nplot += gg.geom_vline(xintercept=context.shape[1], linetype=\"dashed\")\n_ = plot.draw()\n# -\n\n\n# # Sample trajectories\n\n# + colab={} colab_type=\"code\" id=\"WdKcHr6_n_ba\"\nsample_x, sample_y = next(valid_ds)\nsample_x = sample_x[:1]  # Shrink to batch-size 1.\nsample_y = sample_y[:1]  # Shrink to batch-size 1.\n\n\ncontext_length = SEQ_LEN // 8\nprint(f\"context_length = {context_length}\")\n# Cut the batch-size 1 context from the start of the sequence.\ncontext = sample_x[:, :context_length]\n\n# Reuse the same context from the previous cell.\npredicted = fast_autoregressive_predict(train_state.params, None, context, SEQ_LEN)\n\n# The plots should be equivalent!\nplot = plot_samples(sample_y, predicted)\nplot += gg.geom_vline(xintercept=context.shape[1], linetype=\"dashed\")\n_ = plot.draw()\n# -\n\n\n# ## timeit\n\n# + colab={} colab_type=\"code\" id=\"9S0tkPXGrU3a\"\n# %timeit autoregressive_predict(train_state.params, context, SEQ_LEN)\n# %timeit fast_autoregressive_predict(train_state.params, None, context, SEQ_LEN)\n# -\n# ## Train all stars\n\n\n# ### Training\n\n\ndef split_train_validation_date(dataframe, date, look_back) -> TrainSplit:\n    train_size = len(dataframe.loc[:date])\n    return split_train_validation(dataframe, train_size, look_back)\n\n\n# %%time\ntrain, valid = split_train_validation_date(dataframe_normed, TRAIN_DATE, SEQ_LEN)\nprint(f\"effective train size = {train[0].shape[1]}\")\n\ntrain[0].shape, train[1].shape, valid[0].shape, valid[1].shape\n\ntrain_ds = Dataset(train, BATCH_SIZE)\nvalid_ds = Dataset(valid, BATCH_SIZE)\n# del train, valid  # Don't leak temporaries.\n\n# %%time\ntrain_state, records = train_model(\n    model_with_loss,\n    train_ds,\n    valid_ds,\n    len(train.x) // BATCH_SIZE * 1,\n    jax.random.PRNGKey(42),\n    record_freq=RECORD_FREQ,\n)\n\n# Plot losses\nlosses = pd.DataFrame(records)\ndf = pd.melt(losses, id_vars=[\"step\"], value_vars=[\"train_loss\", \"valid_loss\"])\nplot = (\n    gg.ggplot(df)\n    + gg.aes(x=\"step\", y=\"value\", color=\"variable\")\n    + gg.geom_line()\n    + gg.scales.scale_y_log10()\n)\n_ = plot.draw()\n\n# ### Sampling\n\n# +\n# Grab a sample from the validation set.\nsample_x, sample_y = next(valid_ds)\nsample_x = sample_x[:1]  # Shrink to batch-size 1.\nsample_y = sample_y[:1]  # Shrink to batch-size 1.\n\n\n# Generate a prediction, feeding in ground truth at each point as input.\npredicted, _ = model.apply(train_state.params, None, sample_x)\n\nplot = plot_samples(sample_y, predicted)\n_ = plot.draw()\n# -\n\n# ### Run autoregressively\n\n# +\n# %%time\nsample_x, sample_y = next(valid_ds)\nsample_x = sample_x[:1]  # Shrink to batch-size 1.\nsample_y = sample_y[:1]  # Shrink to batch-size 1.\n\n\ncontext_length = SEQ_LEN // 8\n# Cut the batch-size 1 context from the start of the sequence.\ncontext = sample_x[:, :context_length]\n\n# Reuse the same context from the previous cell.\npredicted = fast_autoregressive_predict(train_state.params, None, context, SEQ_LEN)\n\n# The plots should be equivalent!\nplot = plot_samples(sample_y, predicted)\nplot += gg.geom_vline(xintercept=len(context), linetype=\"dashed\")\n_ = plot.draw()\n", "meta": {"hexsha": "fef2dbdf7939029991a9ebb80a5192eda981285e", "size": 24234, "ext": "py", "lang": "Python", "max_stars_repo_path": "docs/notebooks/05_reconstructing_the_light_curve_of_stars.py", "max_stars_repo_name": "eserie/wax-ml", "max_stars_repo_head_hexsha": "9cf92ff5c41ea681fd3eaaf4560b3380f986ee1e", "max_stars_repo_licenses": ["MIT", "ECL-2.0", "Apache-2.0", "BSD-3-Clause"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2021-06-14T16:27:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T09:51:42.000Z", "max_issues_repo_path": "docs/notebooks/05_reconstructing_the_light_curve_of_stars.py", "max_issues_repo_name": "eserie/wax-ml", "max_issues_repo_head_hexsha": "9cf92ff5c41ea681fd3eaaf4560b3380f986ee1e", "max_issues_repo_licenses": ["MIT", "ECL-2.0", "Apache-2.0", "BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-10-01T12:45:29.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-03T18:06:39.000Z", "max_forks_repo_path": "docs/notebooks/05_reconstructing_the_light_curve_of_stars.py", "max_forks_repo_name": "eserie/wax-ml", "max_forks_repo_head_hexsha": "9cf92ff5c41ea681fd3eaaf4560b3380f986ee1e", "max_forks_repo_licenses": ["MIT", "ECL-2.0", "Apache-2.0", "BSD-3-Clause"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2021-06-11T12:32:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-17T16:13:15.000Z", "avg_line_length": 29.6621787026, "max_line_length": 268, "alphanum_fraction": 0.6829660807, "include": true, "reason": "import numpy,import jax", "num_tokens": 6517, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4882833952958347, "lm_q2_score": 0.19930799790404563, "lm_q1q2_score": 0.09731878592620251}}
{"text": "import os\nfrom sympy import *\nimport pandas as pd\nimport numpy as np\nimport scipy.fftpack\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nplt.style.use(\"seaborn-paper\")\nfrom mpl_toolkits.axes_grid1 import make_axes_locatable\n\n\n\ndef find_nearest(array, value):\n    array = np.asarray(array)\n    idx = (np.abs(array - value)).argmin()\n    return idx\n\ndef find_nearest_value(array, value):\n    array = np.asarray(array)\n    idx = (np.abs(array - value)).argmin()\n    return array[idx]\n\n\n# ## Canvas palette\n\n# In[2]:\n\n\n#Canvas for single plot\nx = np.linspace(0,10,100)\ny = np.sin(x)\nplt.figure(figsize=[14,6])\nplt.grid(True)\nplt.title(\"Change-me!\",fontsize=20)\nplt.plot(x,y,label=\"testvalue\")\nplt.legend(fontsize=16)\nplt.xlabel(\"XLABEL (unit)\",fontsize=18)\nplt.ylabel(\"YLABEL (unit)\",fontsize=18)\nplt.show()\n\n\n# In[3]:\n\n\n#Canvas for side by side\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(14,6))\nfig.suptitle(\"test\",y=1.05,fontsize=20)\n\naxes[0].grid(True)\naxes[0].plot(x,y,label=\"testvalue\")\naxes[0].legend(fontsize=16)\naxes[0].set_title(\"TESTTITLE\",fontsize=18)\naxes[0].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[0].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[0].legend(fontsize=16)\naxes[0].tick_params(axis='both', which='major', labelsize=15)\n\n\naxes[1].grid(True)\naxes[1].plot(x,y,label=\"testvalue\")\naxes[1].legend(fontsize=16)\naxes[1].set_title(\"TESTTITLE\",fontsize=18)\naxes[1].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[1].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[1].legend(fontsize=16)\naxes[1].tick_params(axis='both', which='major', labelsize=15)\n\nfig.tight_layout()\nplt.show()\n\n\n# In[4]:\n\n\n#Canvas for side by side\nfig, axes = plt.subplots(nrows=2, ncols=4, figsize=(14,6))\nfig.suptitle(\"test\",y=1.05,fontsize=20)\n\naxes[0,0].grid(True)\naxes[0,0].plot(x,y,label=\"testvalue\")\naxes[0,0].legend(fontsize=16)\naxes[0,0].set_title(\"TESTTITLE\",fontsize=18)\naxes[0,0].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[0,0].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[0,0].legend(fontsize=16)\naxes[0,0].tick_params(axis='both', which='major', labelsize=15)\n\n\naxes[0,1].grid(True)\naxes[0,1].plot(x,y,label=\"testvalue\")\naxes[0,1].legend(fontsize=16)\naxes[0,1].set_title(\"TESTTITLE\",fontsize=18)\naxes[0,1].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[0,1].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[0,1].legend(fontsize=16)\naxes[0,1].tick_params(axis='both', which='major', labelsize=15)\n\nfig.tight_layout()\nplt.show()\n\n\n# ## Read data\n\n# In[2]:\n\n\n#Folder and paths definitions\nmain_path  = os.getcwd()\ndatafolder_path = main_path+\"/results\"\nresults_dir = \"/output_py\" \noutput_dir = main_path+results_dir\ntry:\n    os.mkdir(output_dir)\nexcept OSError:\n    print (\"Creation of the directory %s failed\" % results_dir)\nelse:\n    print (\"Successfully created the directory %s \" % results_dir)\n\n\n# In[27]:\n\n\nKvalues = np.linspace(0,6,30)\nKvalues = np.around(Kvalues, decimals=3)\n\n\n# In[28]:\n\n\npvalues = [0, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, .95, 1]\n\n\n# In[9]:\n\n\n#Create dataframe dictionary. For each entry, first value is the K of the dataframe (second value)\ndata = []\nfor i in range(0,len(Kvalues)):\n    for j in pvalues:\n        filename = datafolder_path + \"/WS_gfreq_uphase_N2000_NOMF_T20000_dt0.0100_nruns10_K%.3f_p=%.3f.tsv\"%(Kvalues[i],j)\n        #cols refers to timestep, avgmod, stdmod, avgphase,stdphase (of order parameter)\n        df = pd.read_csv(filename,sep=\"\\t\",header=None)\n        data.append([Kvalues[i],j,df])\n    \n\n\n# In[10]:\n\n\n#data[0][x]#, x=0=> K, x=1=>p, x=2=> df \n\n\n# In[11]:\n\n\ndef rinf_avg(df):\n    lasts = df[1][int(T*.9):-1]\n    return np.mean(lasts)\n\ndef rinf_std(df):\n    lasts = df[1][int(T*.9):-1]\n    return np.std(lasts)\n\n\n# In[12]:\n\n\nK_plot = []\np_plot = []\nr_inf_avg = []\nr_inf_std = []\nfor i in range(0,len(data)):\n    t_plot = data[i][2][0]\n    K_plot.append(data[i][0])\n    p_plot.append(data[i][1])\n    r_inf_avg.append(rinf_avg(data[i][2]))\n    r_inf_std.append(rinf_std(data[i][2]))\n\n\n# In[29]:\n\n\nr_inf_mat = np.zeros(shape=[len(pvalues),len(Kvalues)])\nfor i in range(0,len(data)):\n    r_inf_mat[find_nearest(pvalues, data[i][1])][find_nearest(Kvalues, data[i][0])] = rinf_avg(data[i][2])\n\nplt.figure(figsize=[10,10])\nax = plt.gca()\n#name = \"Kuramoto oscillators on Watts-Strogatz network \\n N = %d, r = %d, dt = %.3f, %s, n_runs = %d\\n$r_{\\\\infty}$\"%(N,2,dt,freq_plot, n_runs)\n\nim = plt.imshow(r_inf_mat)\nplt.title(\"Kuramoto oscillators on Watts-Strogatz network\\n N=%d, $r_{WS}$=%d, T=%d, dt=%.3f, %s, n_runs=%d\\n $r_{\\\\infty}$\"%(N,3,T,dt,freq_plot,n_runs),fontsize=20)\n\nplt.yticks(np.linspace(0,len(pvalues)-1,len(pvalues)),pvalues)\nplt.ylabel(\"p\",fontsize=18,rotation=0)\nplt.xticks(np.linspace(0,len(Kvalues)-1,len(Kvalues)),Kvalues,rotation=45)\nplt.xlabel(\"K\",fontsize=18)\n\ndivider = make_axes_locatable(ax)\ncax = divider.append_axes(\"right\", size=\"5%\", pad=0.15)\ncbar = plt.colorbar(im, cax=cax)\n\nplt.tight_layout()\nplt.savefig(output_dir+config_name+\"WS_rinf_heatmap.png\")\n\nplt.show()\n\n\n# In[14]:\n\n\nKcs_df = pd.DataFrame([p_plot,K_plot,r_inf_avg,r_inf_std]).T\n\n\n# In[15]:\n\n\nKcs_df = Kcs_df.sort_values(by=[0,1])\n\n\n# In[31]:\n\n\nKc_plot = []\n\nfor i in range(0,len(pvalues)):\n\n    idx_kc = find_nearest(Kcs_df[0+i*len(Kvalues)+1:len(Kvalues)*(i+1)][2],.5)\n    rinf_value = find_nearest_value(Kcs_df[0+i*len(Kvalues)+1:len(Kvalues)*(i+1)][2],.5)\n    df = Kcs_df[0+i*len(Kvalues)+1:len(Kvalues)*(i+1)]\n    df = df.reset_index(inplace = False) \n    Kc_plot.append([pvalues[i],df[1].iloc[idx_kc]])\n    print(\"prob\",pvalues[i],\", rinf %.3f\"%(rinf_value),\", K\",df[1].iloc[idx_kc])\nKc_plot = pd.DataFrame(Kc_plot, columns=[\"p\",\"Kc\"])\n\n\n# In[54]:\n\n\nimport matplotlib.pyplot as plt\nfrom scipy.optimize import curve_fit\n\n\n# In[55]:\n\n\ndef func(x, a, b):\n    return a+ b/x\n\n\n# In[66]:\n\n\npopt, pcov = curve_fit(func, Kc_plot[\"p\"][2:],Kc_plot[\"Kc\"][2:], p0=[1.6,2])\npopt\n\n\n# In[70]:\n\n\nx_fit = np.linspace(Kc_plot[\"p\"][2],1,100)\ny_fit = func(x_fit,popt[0],popt[1])\n\n\n# In[94]:\n\n\nplt.figure(figsize=[14,6])\nplt.grid(True,alpha=.3)\nplt.title(\"Kuramoto oscillators on Watts-Strogatz network\\n N=%d, $r_{WS}$=%d, T=%d, dt=%.3f, %s, n_runs=%d\\n $K_{c}(p)$\"%(N,3,T,dt,freq_plot,n_runs),fontsize=20)\nplt.plot(x_fit,y_fit,label=\"y(p) = a + $\\\\frac{b}{p}$ fit\")\nplt.plot(Kc_plot[\"p\"],Kc_plot[\"Kc\"],c='b',marker='o',markersize=12,ls='',label=\"Raw Data\")\nplt.plot(Kc_plot[\"p\"][2:],Kc_plot[\"Kc\"][2:],c='r',marker='o',markersize=9,ls='--',linewidth=.7,label=\"Fitted Data\")\nplt.xticks(pvalues,pvalues)\nplt.xlabel(\"p\",fontsize=18,rotation=0)\nplt.yticks(Kvalues,Kvalues)\nplt.ylim(min(Kc_plot[\"Kc\"])*.85,max(Kc_plot[\"Kc\"])*1.1)\nplt.legend(fontsize=18)\n\nplt.text(.5,4,\"a = %.4f$\\pm$%.4f, b = %.4f$\\pm$%.4f\"%(popt[0],pcov[0,0],popt[1],pcov[1,1]),fontsize=20)\n\nplt.tight_layout()\nplt.savefig(output_dir+config_name+\"WS_Kc(p).png\")\n\n\n\n", "meta": {"hexsha": "9291ed9a698a559b269652879dc8307a8cf2d385", "size": 6775, "ext": "py", "lang": "Python", "max_stars_repo_path": "Code/Python/Bonus_part/WS_analysis.py", "max_stars_repo_name": "spicella/Intro_to_ComplexSystems-Kuramoto", "max_stars_repo_head_hexsha": "64c027f1f0d16b2358d6889de453c1474d3dea6b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-01-04T22:36:10.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-04T22:36:10.000Z", "max_issues_repo_path": "Code/Python/Bonus_part/WS_analysis.py", "max_issues_repo_name": "spicella/Intro_to_ComplexSystems-Kuramoto", "max_issues_repo_head_hexsha": "64c027f1f0d16b2358d6889de453c1474d3dea6b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-01-01T16:13:24.000Z", "max_issues_repo_issues_event_max_datetime": "2020-01-01T16:13:24.000Z", "max_forks_repo_path": "Code/Python/Bonus_part/WS_analysis.py", "max_forks_repo_name": "spicella/IntroCS-Kuramoto", "max_forks_repo_head_hexsha": "64c027f1f0d16b2358d6889de453c1474d3dea6b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.606271777, "max_line_length": 165, "alphanum_fraction": 0.6701107011, "include": true, "reason": "import numpy,import scipy,from scipy,from sympy", "num_tokens": 2321, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48828339529583464, "lm_q2_score": 0.19682620128743877, "lm_q1q2_score": 0.09610696584781199}}
{"text": "# coding:utf-8\n# usr/bin/python3\n# python src/chapter32/chapter32note.py\n# python3 src/chapter32/chapter32note.py\n\"\"\"\n\nClass Chapter32_1\n\nClass Chapter32_2\n\nClass Chapter32_3\n\nClass Chapter32_4\n\n\"\"\"\nfrom __future__ import absolute_import, division, print_function\n\nimport math\nimport re\nimport numpy as np\n\nif __name__ == '__main__':\n    import stringmatch as sm\nelse:\n    from . import stringmatch as sm\n\nclass Chapter32_1:\n    \"\"\"\n    chapter32.1 note and function\n    \"\"\"\n    def __init__(self):\n        pass\n\n    def note(self):\n        \"\"\"\n        Summary\n        ====\n        Print chapter32.1 note\n\n        Example\n        ====\n        ```python\n        Chapter32_1().note()\n        ```\n        \"\"\"\n        print('chapter32.1 note as follow')\n        print('第32章 字符串匹配')\n        print('在文本编辑程序中,经常出现要在一段文本中找出某个模式的全部出现位置这一问题。典型情况是,一段文本是正在编辑的文件,',\n            '所搜寻的模式是用户提供的一个特定单词。解决这个问题的有效算法能极大地提高文本编辑程序的响应性能',\n            '字符串匹配算法也常常用于其他方面,例如在DNA序列中搜寻特定的模式')\n        print('字符串匹配问题的形式定义是这样的:假设文本是一个长度为n的数组T[1..n],模式是一个长度为m<=n的数组P[1..m].',\n            '进一步假设P和T的元素都是属于有限字母表∑表中的字符.例如可以有∑={0,1}或∑={a,b,...,z},字符数组P和T常称为字符串')\n        print('如果0<=s<=n-m,并且T[S+1,...,s+m]=P[1..m](即对1<=j<=m,有T[s+j]=P[j]),则说模式P在文本T中出现且位移为s.',\n            '(或者等价地,模式P在文本T中从位置s+1开始出现)。如果P在T中出现且位移为s,则称s为一个有效位移,否则称s为无效位移',\n            '这样一来,字符串匹配问题就变成一个在一段指定的文本T中,找出某指定模式P出现所有有效位移的问题')\n        print('本章的每个字符串匹配算法都对模式进行了一些预处理,然后找寻所有有效位移;我们称第二步为“匹配”.',\n            '每个算法的总运行时间为预处理和匹配时间的总和.')\n        print('32.2节介绍由Rabin和Karp发现的一种有趣的字符串匹配算法,该算法在最坏情况下的运行时间为Θ((n-m+1)m),虽然这一时间并不比朴素的算法好',\n            '但是在平均情况和实际情况中,该算法的效果要好的多.这种算法也可以很好地推广到解决其他的模式匹配问题')\n        print('32.3节中描述另一种字符串匹配算法,该算法构造一个特别设计的有限自动机,用来搜寻某给定模式P在文本中的出现的位置',\n            '此算法用O(m|∑|)的预处理时间,但只用Θ(n)的匹配时间')\n        print('32.4节介绍与其类似但更巧妙的Knuth-Morris-Pratt(或KMP)算法。该算法的匹配时间同样为Θ(n),但是将预处理时间降至Θ(m)')\n        print('算法          预处理时间        匹配时间')\n        print('朴素算法          0           O((n-m+1)m)')\n        print('Rabin-Karp       Θ(m)        O((n-m+1)m)')\n        print('有限自动机算法   O(m|∑|)         Θ(n)')\n        print('KMP算法          Θ(m)           Θ(n)')\n        print('记号与术语')\n        print('  用∑*表示用字母表∑中的字符形成的所有有限长度的字符串的集合.在本章中仅考虑长度有限的字符串',\n            '长度为0的空字符串用e表示,它也属于∑*.字符串x的长度用|x|表示.两个字符串x和y的连接表示为xy,其长度为|x|+|y|,由x的字符接y的字符组成')\n        print('  如果对某个字符串与y∈∑*,有x=wy,就说字符串w是字符串x的前缀,表示为w∝x,得知|w|<=|x|.空字符串e既是每个字符串的前缀,也是每个字符串的后缀',\n            '例如,有ab>abcca,cca<abcca.对任意字符串x和y及任意字符a,x>y当且仅当xa>ya.注意>和<都是传递关系')\n        print('引理32.1(重叠后缀定理)假设x,y和z是满足x>z和y<z的三个字符串.如果|x|<=|y|,则x>y;如果|x|>=|y|,则y>x;如果|x|=|y|,则x=y')\n        print('  本章中允许把比较两个等长的字符串是否相等的操作当做原语操作.如果对字符串的比较是从左往右进行,并且发现一个不匹配字符时比较就终止,',\n            '则假设这样一个测试过程所需的时间是关于所发现的匹配字符数目的线性函数')\n        print('32.1 朴素的字符串匹配算法')\n        print('朴素的字符串匹配算法:它用一个循环来找出所有有效位移,该循环对n-m+1可能的每一个s值检查条件P[1..m]=T[s+1..s+m]')\n        print('这种朴素的字符串匹配过程可以形象地看成用一个包含模式的“模板”沿文本滑动,同时对每个位移注意模板上的字符是否与文本的相应字符相等')\n        print('NATIVE-STRING-MATCHER的运行时间为Θ((m-m+1)m)')\n        print('在本章中还要介绍一种算法,它的最坏情况预处理时间为Θ(m),最坏情况匹配时间为Θ(n)')\n        print('练习31.1-1 解答过程如下：')\n        P = '0001'\n        T = '000010001010001'\n        sm.native_string_matcher(T, P)\n        print('练习31.1-2 假设模式P中的所有字符都是不同的。试说明如何对一段n个字符的文本T加速过程NATIVE-STRING-MATCHER的执行速度,',\n            '使其运行时间达到O(n)')\n        print('练习31.1-3 假设模式P和文本T是长度分别为m和n的随机选取的字符串,其字符串属于d个元素的字母表∑={0,1,...,d-1},其中d>=2',\n            '证明朴素算法第4行中隐含的循环所执行的字符比较的预计次数为')\n        print('   (n-m+1)(1-d**-m)/(1-d**-1)<=2(n-m+1)')\n        print('练习31.1-4 假设允许模式P中包含一个间隔字符◇,该字符可以与任意的字符串匹配(甚至可以与长度为0的字符串匹配)',\n            '例如,模式ab◇ba◇c')\n        # python src/chapter32/chapter32note.py\n        # python3 src/chapter32/chapter32note.py\n\nclass Chapter32_2:\n    \"\"\"\n    chapter32.2 note and function\n    \"\"\"\n    def __init__(self):\n        pass\n\n    def note(self):\n        \"\"\"\n        Summary\n        ====\n        Print chapter32.2 note\n\n        Example\n        ====\n        ```python\n        Chapter32_2().note()\n        ```\n        \"\"\"\n        print('chapter32.2 note as follow')\n        print('Rabin-Karp算法')\n        print('在实际应用中,Rabin和Karp所建议的字符串匹配算法能够较好的运行,我们还可以从中归纳出有关问题的其他算法,如二维模式匹配')\n        print('Rabin-Karp算法预处理时间为')\n        print('Θ(m),在最坏情况下的运行时间为O((n-m+1)m),但是它的平均情况运行时间还是比较好的')\n        print('假定∑={0,1,2,...,9},这样每个字符都是一个十进制数字(一般情况下,可以假定每个字符都是基数为d的表示法中一个数字,d=|∑|).',\n            '可以用一个长度为k的十进制数来表示由k个连续字符组成的字符串.因此,字符串31415就对应于十进制数31415',\n            '如果输入字符既可以看做图形符号,也可以看做数字')\n        print('已知一个模式P[1..m],设p表示其相应的十进制数的值。对于给定的文本T[1..n],用ts来表示其长度为m的子字符串T[s+1..s+m](s=0,1,...,n - m)相应的十进制数的值')\n        print('当然,用ts来表示其长度为m的子字符串T[s+1..s+m](s=0,1,..,n-m)相应十进制数的值.当然,ts=p当且仅当T[s+1..s+m]=P[1..m],因此s是有效位移当且仅当ts=p',\n            '如果能够在Θ(m)的时间内计算出p的值,并在总共Θ(n-m+1)的时间内计算出所有ts的值,那么通过把p值与每个ts值进行比较,能够在Θ(n)的时间内,求出有效位移s')\n        print('可以运用霍纳法则,在Θ(m)的时间内计算出p的值：')\n        print('  p=P[m]+10(P[m-1]+10(P[m-2]+...+10(P[2]+10P[1])...))')\n        print('类似地,也可以在Θ(m)的时间内,根据T[1..m]计算出t0的值')\n        print('为了在Θ(n-m)的时间内计算出剩余的值t1,t2,...,tn-m,可以在常数时间内根据ts计算出ts+1,这是因为霍纳法则')\n        print('RABIN-KARP-MATCHER的预处理时间Θ(m),其匹配时间在最坏情况下为Θ((n-m+1)m),因为Rabin-Karp算法与朴素的字符串匹配算法一样,对每个有效位移进行显示验证',\n            '如果P=a^m并且T=a^n,则验证所需的时间为Θ((n-m+1)m),因为n-m+1可能的位移中每一个都是有效位移')\n        print('在许多实际作用中,有效位移数很少(如只有常数c个),因此,算法的期望匹配时间为O((n-m+1)+cm)=O(n+m),',\n            '再加上处理伪命中点所需的时间.假设减少模q的值就像是从∑*到Zq上的一个随机映射,基于这种假设,进行启发性分析',\n            '要正式证明这个假设是比较困难的,但是有一种可行的方法,就是假定q是从适当大的整数中随机得出的.可以预计伪命中的次数为O(n/q)',\n            '因为可以估计出任意的ts对模q等价于p的概率为1/q.')\n        print('Rabin-Karp算法的期望运行时间为:O(n)+O(m(v+n/q))')\n        print('练习32.2-1 如果取模q=11,那么当Rabin-Karp匹配算法在文本T=3141592653589793中与搜寻模式P=26,会遇到多少个伪命中点')\n        sm.native_string_matcher('3141592653589793', '26')\n        sm.rabin_karp_matcher('3141592653589793', '26', 10, 11)\n        print('练习32.2-2 如何扩展Rabin-Karp方法,使其能解决这样的问题:如何在文本字符串中搜寻出给定的k个模式中任何一个出现',\n            '起初假定所有k个模式都是等长的.然后扩展算法允许不同长度的模式')\n        print('练习32.2-3 试说明如何扩展Rabin-Karp方法以处理下列问题,在一个n*n二维字符串中搜寻出给定的m*m模式',\n            '(可以使该模式在水平方向和垂直方向移动,但不可以把模式旋转)')\n        print('练习32.2-4 Alice有一份很长的n位文件的复印件A=<an-1,an-2,...,a0>,Bob也有一份类似的文件B=<bn-1,bn-2,...,b0>',\n            'Alice和Bob都希望知道他们的文件是否一样，为了避免传送整个文件A或B.',\n            '运用下列快速概率检查手段,一起选择一个素数q>1000n,并从{0,1,...,q-1}中随机选取一个整数x,然后Alice求出：',\n            'A(x)=(∑aixi) mod q)的值,Bob也用类似的方法计算出B(x).',\n            '证明：如果A≠B,则A(x)=B(x)的概率至多为1/1000;如果两个文件相同,则A(x)的值必定等于B(x)的值') \n        # python src/chapter32/chapter32note.py\n        # python3 src/chapter32/chapter32note.py\n\nclass Chapter32_3:\n    \"\"\"\n    chapter32.3 note and function\n    \"\"\"\n    def __init__(self):\n        pass\n\n    def note(self):\n        \"\"\"\n        Summary\n        ====\n        Print chapter32.3 note\n\n        Example\n        ====\n        ```python\n        Chapter32_3().note()\n        ```\n        \"\"\"\n        print('chapter32.3 note as follow')\n        print('32.3 利用有限自动机进行字符串匹配')\n        print('很多字符串匹配算法都要建立一个有限自动机,它通过对文本字符串T进行扫描的方法,',\n            '找出模式P的所有出现位置.建立这样自动机的方法,用于字符串匹配：它们只对每个文本字符检查一次,并且检查每个文本字符的时间为常数',\n            '因此,在建立好自动机后所需要的时间为Θ(n),但是如果∑很大,建立自动机所花的时间也可能是很多的')\n        print('在本节的开头先定义有限自动机概念.考察一种一种特殊的字符串匹配自动机,并说明如何利用它找出一个模式在文本中的出现位置',\n            '包括对一段给定的文本,如何模拟出字符串匹配自动机的执行步骤的一些细节.',\n            '将说明对一个给定的输入模式,如何构造相应的字符串匹配自动机')\n        print('有限自动机')\n        print('  一个有限自动机M是一个5元组(Q,q0,A,∑,d)')\n        print('   Q是一个状态的有限集合')\n        print('   q0∈Q是初始状态')\n        print('   A∈Q是一个接受状态集合')\n        print('   ∑是有限的输入字母表')\n        print('   d是一个从Q×∑到Q的函数,称为M的转移函数')\n        print('  有限自动机开始于状态q0,每次读入输入字符串的一个字符.如果有限自动机在状态q时读入了输入字符a,则它从状态q变为状态d(q,a)(进行了一次转移).',\n            '每当其状态q属于A时,就说自动机M接受了所有读入的字符串。没有被接收的输入称为被拒绝的输入')\n        print('  有限自动机M可以推导出一个函数∮,称为终止函数,它是从∑*到Q的函数,并满足:∮(w)是M在扫描字符串w终止时的状态.',\n            '因此,M接受字符串w当且仅当∮(w)∈A,函数∮由下列递归关系定义∮(e)∈q0',\n            '∮(wa)=d(∮(w), a) 对于w∈∑*, a∈∑')\n        print('字符串匹配自动机')\n        print('  对每个模式P都存在一个字符串匹配自动机,必须在预处理阶段,根据模式构造出相应的自动机后,才能利用它来搜寻文本字符串',\n            '关于模式P=ababaca的有限自动机的构造过程。从现在开始,假定P是一个已知的固定模式.为了使说明上的简洁,在下面的概念中将不特别指出对P的依赖关系')\n        print('  为了详细说明与给定模式P[1..m]相应的字符串匹配自动机,首先定义一个辅助函数a,称为相应P的后缀函数。',\n            '函数a是一个从∑*到{0,1,...,m}上定义的映射,a(x)是x的后缀P的最长前缀的长度：a(x)=max{k:Pk>x}')\n        print('  为了清楚地说明字符串匹配自动机的操作过程,给出一个简单而有效的程序,用来模拟这样一个自动机(用它的变迁函数d来表示),在输入文本T[1..n]中,',\n            '寻找长度为m的模式P的出现位置的过程,对于长度为m的模式的任意字符串匹配自动机来说,状态Q为{0,1,...,m},初始状态为0,唯一的接收态是状态m')\n        print('  由FINITE-AUTOMATON-MATCHER的简单循环结构可以看出,对于一个长度为n的文本字符串,它的匹配时间为Θ(n)',\n            '但是,这一匹配时间没有包括计算变迁函数d所需要的预处理时间.将在证明FINITE-AUTOMATON-MATCHER的正确性以后,再来讨论这一问题')\n        print('  考察自动机在输入文本T[1..n]上进行的操作.将证明自动机扫过字符T[i]后,其状态为d(Ti).因为d(Ti)=m当且仅当P>Ti,',\n            '所以自动机处于接收状态m,当且仅当模式P已经被扫描过,为了证明这个结论,要用到下面两条关于后缀函数o的引理')\n        print('引理32.2 (后缀函数不等式) 对任意字符串x和字符a,有o(xa)>=o(x)+1')\n        print('引理32.3 (后缀函数递归引理) 对任意x和字符a,如果q=o(x),则o(xa)=o(Pqa)')\n        print('定理32.4 如果∮是字符串匹配自动机关于给定模式P的终态函数,T[1..n]是自动机的输入文本,对i=0,1,...,n,有∮(Ti)=o(Ti)')\n        print('计算变迁函数')\n        print('练习32.3-1 对模式P=aabab构造出相应的字符串匹配自动机,并说明它在文本字符串T=aaababaabaababaab上的操作过程')\n        print(sm.finite_automaton_matcher('aaababaabaababaab', 10, 8))\n        print('练习32.3-2 对字母表∑={a, b},画出与模式ababbabbababbababbabb相应的字符串匹配自动机状态转换图')\n        print('练习32.3-3 如果由Pk>Pq蕴含着k=0或k=q,则称模式P是不可重叠的.试描述与不可重叠模式相应的字符串匹配自动机的状态转换图')\n        print('练习32.3-4 已知两个模式P和P`,试描述如何构造一个有限自动机,使之能确定其中任意一个模式的所有出现位置.要求尽量使自动机的状态数最小')\n        print('练习32.3-5 已知一个包括间隔字符的某模式P,说明如何构造一个有限自动机,使其在O(n)的时间内,找出P在文本T中的一次出现位置,其中n=|T|')\n        # python src/chapter32/chapter32note.py\n        # python3 src/chapter32/chapter32note.py\n\nclass Chapter32_4:\n    \"\"\"\n    chapter32.4 note and function\n    \"\"\"\n    def __init__(self):\n        pass\n\n    def note(self):\n        \"\"\"\n        Summary\n        ====\n        Print chapter32.4 note\n\n        Example\n        ====\n        ```python\n        Chapter32_4().note()\n        ```\n        \"\"\"\n        print('chapter32.4 note as follow')\n        print('32.4 Knuth-Morris-Pratt算法')\n        print('Knuth、Morris和Pratt三人设计的线性时间字符串匹配算法。这个算法不用计算变迁函数d,匹配时间为Θ(n),只要用到辅助函数pi[1,m]',\n            '它是在Θ(m)时间内,根据模式预先计算出来的.数组pi使得我们可以按需要,“现场”有效地计算(在平摊意义上来说)变迁函数d.',\n            '粗略地说,对任意状态q=0,1,...,m和任意字符a∈∑,pi[q]的值包含了与a无关但在计算d(q,a)时需要的信息',\n            '由于数组pi只有m个元素,而d有Θ(m|∑|个值,所以通过预先计算pi而不是d,使得时间减少了一个|∑|因子)')\n        print('关于模式的前缀函数')\n        print('  模式的前缀函数pi包含有模式与其自身的位移进行匹配的信息.这些信息可用于避免在朴素的字符串匹配算法中,对无位移进行测试,',\n            '也可以避免在字符串匹配自动机中,对d的预先计算过程')\n        print('KMP-MATCHER的大部分过程都是在模仿FINITE-AUTOMATON-MATCHER.KMP-MATCHER调用了一个辅助过程COMPUTE-PREFIX-FUNCTION来计算pi')\n        print('运行时间分析')\n        print('  运用平摊分析方法进行分析后可知,过程COMPUTE-PREFIX-FUNCTION的运行时间为Θ(m)')\n        print('  在类似的平摊分析中,如果用q的值作为势函数,则KMP-MATCHER的匹配时间为Θ(n)',\n            '与FINITE-AUTOMATON-MATCHER相比,通过运用pi而不是d,可使对模式进行预处理所需的时间由O(m|∑|)下降为Θ(m),同时保持实际的匹配时间为Θ(n)')\n        print('前缀函数计算的正确性')\n        print('  通过对前缀函数pi进行迭代,就能够列举出是某给定前缀Pq的后缀的所有前缀Pk,设',\n            'pi*[q]={pi[q],pi(2)[q],pi(3)[q],...,pi(t)[q]}')\n        print('引理32.5 (前缀函数迭代定理) 设P是长度为m的模式,其前缀函数为pi,对q=1,2,...,m,有pi*[q]={k:k<q且Pk>Pq}')\n        print('引理32.6 设P是长度为m的模式,pi是P的前缀函数.对q=1,2,...,m,如果pi[q]>0,则pi[q]-1∈pi*[q-1]')\n        print('推论32.7 设P是长度为m的模式,pi是P的前缀函数,对q=2,3,...,m')\n        print('KMP算法的正确性')\n        print('  过程KMP-MATCHER可以看做是过程FINITE-AUTOMATON-MATCHER的一次重新实现')\n        print('练习32.4-1 当字母表为∑={a,b},计算相应于模式ababbabbabbababbabb的前缀函数pi')\n        print('练习32.4-2 给出关于q的函数pi*[q]的规模的上界.举例说明所给出的上界是严格的')\n        print('练习32.4-3 试说明如何通过检查字符串PT的pi函数,来确定模式P在文本T中的出现位置(由P和T并置形成的长度为m+n的字符串)')\n        print('练习32.4-4 试说明如何通过以下方式对过程KMP-MATCHER进行改进:把第7行(不是第12行中)出现的pi替换为pi‘.对q=1,2,...,m的递归定义如下：')\n        print('练习32.4-5 写出一个线性时间的算法,','以确定文本T是否是另一个字符串T‘的循环旋转,例如arc和car是彼此的循环旋转')\n        print('练习32.4-6 给出一个有效的算法,计算出相应于某给定模式P的字符串匹配自动机的变迁函数d',\n            '所给出的算法的运行时间应该是O(m|∑|).(提示：证明:如果q=m或P[q+1]!=a,则d(q,a)=d(pi[q],a))')\n        print('思考题32-1 基于重复因子的字符串匹配')\n        print('  设yi表示字符串y与其自身并置i次所得的结果.例如(ab)^3=ababab.如果对某个字符串y∈∑*和某个r>0有x=y^r,则称字符串x∈∑*具有重复因子r.',\n            '设p(x)表示满足x具有重复因子r的最大值')\n        print('  (a) 写出一个有效算法以计算出p(Pi)(i=1,2,...,m),算法的输入为模式P[1..m].算法的运行时间是多少？')\n        print('  (b) 对任何模式p[1..m],设p(P)定义为max(1<=i<=m)p(Pi).证明：如果从长度为m的所有二进制字符串所组成的集中随机地选择模式P,则p*(P)的期望值是O(1)')\n        print('  (c) 论证下列字符串匹配算法可以在O(p*(P)n+m)的运行时间内,正确地找出模式P在文本T[1..n]中的所有出现位置')\n        # python src/chapter32/chapter32note.py\n        # python3 src/chapter32/chapter32note.py\n\nchapter32_1 = Chapter32_1()\nchapter32_2 = Chapter32_2()\nchapter32_3 = Chapter32_3()\nchapter32_4 = Chapter32_4()\n\ndef printchapter32note():\n    \"\"\"\n    print chapter32 note.\n    \"\"\"\n    print('Run main : single chapter thirty-two!')\n    chapter32_1.note()\n    chapter32_2.note()\n    chapter32_3.note()\n    chapter32_4.note()\n\n# python src/chapter32/chapter32note.py\n# python3 src/chapter32/chapter32note.py\n\nif __name__ == '__main__':  \n    printchapter32note()\nelse:\n    pass\n", "meta": {"hexsha": "6372d0e278c4c77ae1b98018bbd8c91e21a8acb5", "size": 12740, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/chapter32/chapter32note.py", "max_stars_repo_name": "Peefy/CLRS_dugu_code-master", "max_stars_repo_head_hexsha": "98f00e75e1b0ebc13a7affb2604bec8501692a19", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-01-31T03:08:50.000Z", "max_stars_repo_stars_event_max_datetime": "2018-04-25T12:57:01.000Z", "max_issues_repo_path": "src/chapter32/chapter32note.py", "max_issues_repo_name": "HideLakitu/IntroductionToAlgorithm.Python", "max_issues_repo_head_hexsha": "33662f46dc346203b220d7481d1a4439feda05d2", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/chapter32/chapter32note.py", "max_forks_repo_name": "HideLakitu/IntroductionToAlgorithm.Python", "max_forks_repo_head_hexsha": "33662f46dc346203b220d7481d1a4439feda05d2", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-03-03T04:49:53.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-13T10:18:58.000Z", "avg_line_length": 43.4812286689, "max_line_length": 117, "alphanum_fraction": 0.6326530612, "include": true, "reason": "import numpy", "num_tokens": 7493, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.45326184801538616, "lm_q2_score": 0.20946968626535545, "lm_q1q2_score": 0.09494461709983816}}
{"text": "from IPython.display import HTML\n\nHTML('''<script>\ncode_show=true; \nfunction code_toggle() {\n if (code_show){\n $('div.input').hide();\n } else {\n $('div.input').show();\n }\n code_show = !code_show\n} \n$( document ).ready(code_toggle);\n</script>\nThe raw code for this IPython notebook is by default hidden for easier reading.\nTo toggle on/off the raw code, click <a href=\"javascript:code_toggle()\">here</a>.''')\n\n<a id=\"top-title\"></a>\n# From Ptolemy to Kepler\n\nPtolemy, Copernicus, Brahe, Kepler\n\n\n\n\n<a id=\"CC-2.1\"></a>\n# Cosmic Calculations 2.1: Kepler’s Third Law\n\nFirst, let's review the three laws discovered by Kepler from the careful measurements of [Tycho Brache](https://physicsworld.com/a/kepler-and-tycho-brahe-the-odd-couple/).  This is one of the most ineteresting stories of scientific collaboration that transformed years of observations into laws about the universe.  I recommend to read/watch [***The Character of Physical Law***](https://www.youtube.com/watch?v=j3mhkYbznBk) by Richard Feynman if you want to indulge in the details.\n\n<p><a href=\"https://commons.wikimedia.org/wiki/File:Tycho-Kepler-Statue-Prague.jpg#/media/File:Tycho-Kepler-Statue-Prague.jpg\"><img src=\"https://upload.wikimedia.org/wikipedia/commons/7/73/Tycho-Kepler-Statue-Prague.jpg\" alt=\"Tycho-Kepler-Statue-Prague.jpg\" width=\"360\" height=\"480\"></a><br>By <a href=\"https://en.wikipedia.org/wiki/hu:User:Both_El%C5%91d\" class=\"extiw\" title=\"w:hu:User:Both Előd\">Both Előd</a> at <a href=\"https://en.wikipedia.org/wiki/hu:\" class=\"extiw\" title=\"w:hu:\">Hungarian Wikipedia</a>, <a href=\"https://creativecommons.org/licenses/by-sa/2.5\" title=\"Creative Commons Attribution-Share Alike 2.5\">CC BY-SA 2.5</a>, <a href=\"https://commons.wikimedia.org/w/index.php?curid=47229075\">Link</a></p>\n\n## Kepler's laws:\n\n***1. The orbit of every planet is an ellipse with the Sun at one of the two foci.***\n\nIn the figure below, you can imagine the yellow dot as the sun, and a planet would be moving on the blue curve a certain distance away from it.  The elliptical orbit can be described by the semi-major and semi-minor axes, which define the eccentricity of the orbit.  \n\n\nLook for the *perihelion* and *aphelion* of Earth's orbit. From those values, what's the flattening of Earth's orbit and its eccentricity?\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom ipywidgets import interact, interactive, fixed, interact_manual\nimport ipywidgets as widgets\n\n# Set default font size for plots:\nfont = {'size'   : 18}\nplt.rc('font',**font)\n\ndef elliptic_orbit(a,b,t):\n    '''Plot an elliptical orbit and see the radial distance from one focal point\n    a= semi-major axis\n    b=semi-minor axis\n    t=location at an angle between 0 and 360'''\n    p=np.linspace(0,2*np.pi,360)\n    x = a*np.cos(p)\n    y = b*np.sin(p) \n    plt.figure('Ellipse2',figsize=(10,5))\n    plt.plot(x,y,'-')\n    plt.axis('equal')\n    plt.grid(True)\n    #t is the angle varying from 0 to 360 degrees\n    X = a*np.cos(t*np.pi/180)\n    Y = b*np.sin(t*np.pi/180)\n    #Conditionals in case of changing length of largest semi-major axis\n    if a>=b:\n        c=np.sqrt(a**2-b**2)\n        plt.scatter(c,0,s=200,c='y')\n        plt.scatter(-c, 0, s=200, facecolors='none', edgecolors='y')\n        plt.arrow(c, 0, X-c, Y, head_width=0.1, head_length=0.1, fc='red', ec='red')\n        plt.scatter(X,Y,s=50,c='b')\n        f=(a-b)/a\n        e=c/a\n        #print('Orbital flattening : ',f)\n        print('Orbital eccentricity : ',e)\n        #plt.show()\n    else:\n        c=np.sqrt(b**2-a**2)\n        plt.scatter(0,c,s=200,c='y')\n        plt.scatter(0, -c, s=200, facecolors='none', edgecolors='y')\n        plt.arrow(0, c, X, Y-c, head_width=0.1, head_length=0.1, fc='red', ec='red')\n        plt.scatter(X,Y,s=50,c='b')\n        f=(b-a)/b\n        e=c/b\n        #print('Orbital flattening : ',f)\n        print('Orbital eccentricity : ',e)\n    plt.show()\n    return\n\ninteractive(elliptic_orbit, a = (0,20,1),b=(0,20,1),t=(0,360,20),continuous_update=False)\n        \n\nThe reason the orbits are ellipses, and not circles, would not be understood until the arrival of Newton's equations on Gravitation.  \n\n***2. A line joining a planet and the Sun sweeps out equal areas during equal intervals of time.***\n\n<p><a href=\"https://commons.wikimedia.org/wiki/File:Kepler-second-law.gif#/media/File:Kepler-second-law.gif\"><img src=\"https://upload.wikimedia.org/wikipedia/commons/6/69/Kepler-second-law.gif\" alt=\"Kepler-second-law.gif\"></a><br>By <a href=\"https://en.wikipedia.org/wiki/User:Gonfer\" class=\"extiw\" title=\"en:User:Gonfer\">Gonfer</a> (<a href=\"//commons.wikimedia.org/wiki/User_talk:Gonfer\" title=\"User talk:Gonfer\">talk</a>) - <a href=\"https://en.wikipedia.org/wiki/User:Gonfer\" class=\"extiw\" title=\"en:User:Gonfer\">Gonfer</a>, <a href=\"https://creativecommons.org/licenses/by-sa/3.0\" title=\"Creative Commons Attribution-Share Alike 3.0\">CC BY-SA 3.0</a>, <a href=\"https://commons.wikimedia.org/w/index.php?curid=24871608\">Link</a></p>\n\n\nWhen Kepler discovered his third law ($p^2 = a^3$), he knew only that it applied to the orbits of planets about the Sun. In fact, it applies to any orbiting object as long as the following two conditions are met: \n\n1. The object orbits the Sun or another star of precisely the same mass. \n2. We use units of years for the orbital period and AU for the orbital distance. (Newton extended the law to all orbiting objects; see [Cosmic Calculations 7.1](#CC-7.1).) \n\nIn other words, these two conditions make the relationship a perfect equality.\n\n**Example 1:** The largest asteroid, Ceres, orbits the Sun at an average distance (semimajor axis) of 2.77 AU. What is its orbital period? \n\n***Solution:*** Both conditions are met, so we solve Kepler’s third law for the orbital period $p$ and substitute the given orbital distance, $a = 2.77~AU$.\n\n\n$$p^2 = a^3$$\n\n$$ p = \\sqrt{a^3} = \\sqrt{2.77^3} \\approx 4.6~y$$\n\nCeres has an orbital period of 4.6 years. \n\n**Example 2:** A planet is discovered orbiting every three months around a star of the same mass as our Sun. What is the planet’s average orbital distance? \n\n***Solution:*** The first condition is met, and we can satisfy the second by converting the orbital period from months to years: $p = 3$ months = 0.25 year. We now solve Kepler’s third law for the average distance a: \n\n$a = \\sqrt[3]{p^2}$\n\n$a = \\sqrt[3]{0.25^2} \\approx 0.40~AU$\n\nThe planet orbits its star at an average distance of $0.40~AU$, which is nearly the same as Mercury’s average distance from the Sun.\n\nThese observations offered clear proof that Earth is not the center of everything.* Although we now recognize that Galileo won the day, the story was more complex in his own time, when Catholic Church doctrine still held Earth to be the center of the universe. On June 22, 1633, Galileo was brought before a Church inquisition in Rome and ordered to recant his claim that Earth orbits the Sun. Nearly 70 years old and fearing for his life, Galileo did as ordered and his life was spared. However, legend has it that as he rose from his knees, he whispered under his breath, Eppur si muove— Italian for “And yet it moves.” (Given the likely consequences if Church officials had heard him say this, most historians doubt the legend.) The Church did not formally vindicate Galileo until 1992, but the Church had given up the argument long before that. Today, Catholic scientists are at the forefront of much astronomical research, and official Church teachings are compatible not only with Earth’s planetary status but also with the theories of the Big Bang and the subsequent evolution of the cosmos and of life.\n\n\n<object classid=\"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000\" width=\"750\" height=\"400\"><param name=\"movie\" value=\"KeplerFirstLaw.swf\" /><!--[if !IE]>--><object type=\"application/x-shockwave-flash\" data=\"KeplerFirstLaw.swf\" width=\"750\" height=\"400\"><!--<![endif]--><p>flash animation</p><!--[if !IE]>--></object><!--<![endif]--></object>\n\n\n[Go back to the top of the page](#top-title)\n\n", "meta": {"hexsha": "fa0fe4246614c87cb8512347036f4efd90b216af", "size": 7989, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/content/01/3/from_ptolemy_to_kepler.py", "max_stars_repo_name": "edur409/ASTROBIOLOGY200", "max_stars_repo_head_hexsha": "868d02a10b4be5f71935325c43e89b02567e4e26", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_build/jupyter_execute/content/01/3/from_ptolemy_to_kepler.py", "max_issues_repo_name": "edur409/ASTROBIOLOGY200", "max_issues_repo_head_hexsha": "868d02a10b4be5f71935325c43e89b02567e4e26", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/content/01/3/from_ptolemy_to_kepler.py", "max_forks_repo_name": "edur409/ASTROBIOLOGY200", "max_forks_repo_head_hexsha": "868d02a10b4be5f71935325c43e89b02567e4e26", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 58.3138686131, "max_line_length": 1108, "alphanum_fraction": 0.7080986356, "include": true, "reason": "import numpy", "num_tokens": 2283, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3849121444839335, "lm_q2_score": 0.24508501313237172, "lm_q1q2_score": 0.09433619798565421}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # ETHZ: 227-0966-00L\n# # Quantitative Big Imaging\n# # March 28, 2019\n#\n# ## Shape Analysis\n\n# In[1]:\n\n\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n\nplt.rcParams[\"figure.figsize\"] = (8, 8)\nplt.rcParams[\"figure.dpi\"] = 150\nplt.rcParams[\"font.size\"] = 14\nplt.rcParams[\"font.family\"] = [\"sans-serif\"]\nplt.rcParams[\"font.sans-serif\"] = [\"DejaVu Sans\"]\nplt.style.use(\"ggplot\")\nsns.set_style(\"whitegrid\", {\"axes.grid\": False})\n\n\n# # Literature / Useful References\n#\n# - Jean Claude, Morphometry with R\n# - [Online](http://link.springer.com/book/10.1007%2F978-0-387-77789-4) through ETHZ\n# - [Buy it](http://www.amazon.com/Morphometrics-R-Use-Julien-Claude/dp/038777789X)\n# - John C. Russ, “The Image Processing Handbook”,(Boca Raton, CRC Press)\n# - Available [online](http://dx.doi.org/10.1201/9780203881095) within domain ethz.ch (or proxy.ethz.ch / public VPN)\n# - Principal Component Analysis\n#  - Venables, W. N. and B. D. Ripley (2002). Modern Applied Statistics with S, Springer-Verlag\n# - Shape Tensors\n#  - http://www.cs.utah.edu/~gk/papers/vissym04/\n#  - Doube, M.,et al. (2010). BoneJ: Free and extensible bone image analysis in ImageJ. Bone, 47, 1076–9. doi:10.1016/j.bone.2010.08.023\n#  - Mader, K. , et al. (2013). A quantitative framework for the 3D characterization of the osteocyte lacunar system. Bone, 57(1), 142–154. doi:10.1016/j.bone.2013.06.026\n#\n#  - Wilhelm Burger, Mark Burge. Principles of Digital Image Processing:\n#   Core Algorithms. Springer-Verlag, London, 2009.\n#  -  B. Jähne. Digital Image Processing. Springer-Verlag,\n#            Berlin-Heidelberg, 6. edition, 2005.\n#  -  T. H. Reiss. Recognizing Planar Objects Using Invariant Image\n#            Features, from Lecture notes in computer science, p. 676. Springer,\n#            Berlin, 1993.\n#  - http://en.wikipedia.org/wiki/Image_moment\n#\n#\n\n# # Previously on QBI ...\n#\n# - Image Enhancment\n#  - Highlighting the contrast of interest in images\n#  - Minimizing Noise\n# - Segmentation\n#  - Understanding value histograms\n#  - Dealing with multi-valued data\n# - Automatic Methods\n#  - Hysteresis Method, K-Means Analysis\n# - Regions of Interest\n#  - Contouring\n# - Machine Learning\n\n# # Learning Objectives\n#\n# ## Motivation (Why and How?)\n# - How do we quantify where and how big our objects are?\n# - How can we say something about the shape?\n# - How can we compare objects of different sizes?\n# - How can we compare two images on the basis of the shape as calculated from the images?\n# - How can we put objects into an finite element simulation? or make pretty renderings?\n\n# # Outline\n#\n# - Motivation (Why and How?)\n# - Object Characterization\n# - Volume\n# - Center and Extents\n# - Anisotropy\n#\n# ***\n#\n# - Shape Tensor\n# - Principal Component Analysis\n# - Ellipsoid Representation\n# - Scale-free metrics\n# - Anisotropy, Oblateness\n# - Meshing\n#  - Marching Cubes\n#  - Isosurfaces\n# - Surface Area\n\n# # Motivation\n#\n#\n# We have dramatically simplified our data, but there is still too much.\n#\n# - We perform an experiment bone to see how big the cells are inside the tissue\n# $$\\downarrow$$ ![Bone Measurement](ext-figures/tomoimage.png)\n#\n# ### 2560 x 2560 x 2160 x 32 bit\n# _56GB / sample_\n# - Filtering and Enhancement!\n# $$\\downarrow$$\n# - 56GB of less noisy data\n#\n# ***\n#\n# - __Segmentation__\n#\n# $$\\downarrow$$\n#\n# ### 2560 x 2560 x 2160 x 1 bit\n# (1.75GB / sample)\n#\n# - Still an aweful lot of data\n\n# # What did we want in the first place\n#\n# ### _Single number_:\n# * volume fraction,\n# * cell count,\n# * average cell stretch,\n# * cell volume variability\n\n# # Component Labeling\n#\n# Once we have a clearly segmented image, it is often helpful to identify the sub-components of this image. The easist method for identifying these subcomponents is called component labeling which again uses the neighborhood $\\mathcal{N}$ as a criterion for connectivity, resulting in pixels which are touching being part of the same object.\n#\n#\n# In general, the approach works well since usually when different regions are touching, they are related. It runs into issues when you have multiple regions which agglomerate together, for example a continuous pore network (1 object) or a cluster of touching cells.\n#\n# Here we show some examples from Cityscape Data taken in Aachen (https://www.cityscapes-dataset.com/)\n\n# In[2]:\n\n\nfrom skimage.io import imread\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\ncar_img = imread(\"ext-figures/aachen_img.png\")\nseg_img = imread(\"ext-figures/aachen_label.png\")[::4, ::4] == 26\nprint(\"image dimensions\", car_img.shape, seg_img.shape)\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 8))\nax1.imshow(car_img)\nax1.set_title(\"Input Image\")\n\nax2.imshow(seg_img, cmap=\"bone\")\nax2.set_title(\"Segmented Image\")\n\n\n# The more general formulation of the problem is for networks (roads, computers, social). Are the points start and finish connected?\n\n# In[3]:\n\n\nfrom skimage.morphology import label\n\nhelp(label)\n\n\n# In[4]:\n\n\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 8))\nax1.imshow(seg_img, cmap=\"bone\")\nax1.set_title(\"Segmented Image\")\nlab_img = label(seg_img)\nax2.imshow(lab_img, cmap=plt.cm.gist_earth)\nax2.set_title(\"Labeled Image\")\n\n\n# In[5]:\n\n\nfig, (ax3) = plt.subplots(1, 1)\nax3.hist(lab_img.ravel())\nax3.set_title(\"Label Counts\")\nax3.set_yscale(\"log\")\n\n\n# # Component Labeling: Algorithm\n#\n# We start off with all of the pixels in either foreground (1) or background (0)\n\n# In[6]:\n\n\nfrom skimage.morphology import label\nimport seaborn as sns\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nseg_img = np.eye(9, dtype=int)\nseg_img[4, 4] = 0\nseg_img += seg_img[::-1]\nsns.heatmap(seg_img, annot=True, fmt=\"d\")\n\n\n# Give each point in the image a unique label\n# - For each point $(x,y)\\in\\text{Foreground}$\n#  - Set value to $I_{x,y} = x+y*width+1$\n\n# In[7]:\n\n\nidx_img = np.zeros_like(seg_img)\nfor x in range(seg_img.shape[0]):\n    for y in range(seg_img.shape[1]):\n        if seg_img[x, y] > 0:\n            idx_img[x, y] = x + y * seg_img.shape[0] + 1\nsns.heatmap(idx_img, annot=True, fmt=\"d\", cmap=\"nipy_spectral\")\n\n\n# In a [brushfire](http://www.sciencedirect.com/science/article/pii/S0921889007000966)-style algorithm\n# - For each point $(x,y)\\in\\text{Foreground}$\n#     - For each point $(x^{\\prime},y^{\\prime})\\in\\mathcal{N}(x,y)$\n#     - if $(x^{\\prime},y^{\\prime})\\in\\text{Foreground}$\n#         - Set the label to $\\min(I_{x,y}, I_{x^{\\prime},y^{\\prime}})$\n# - Repeat until no more labels have been changed\n\n# In[8]:\n\n\nfig, m_axs = plt.subplots(2, 2, figsize=(20, 20))\nlast_img = idx_img.copy()\nimg_list = [last_img]\nfor iteration, c_ax in enumerate(m_axs.flatten(), 1):\n    cur_img = last_img.copy()\n\n    for x in range(last_img.shape[0]):\n        for y in range(last_img.shape[1]):\n            if last_img[x, y] > 0:\n                i_xy = last_img[x, y]\n                for xp in [-1, 0, 1]:\n                    if (x + xp < last_img.shape[0]) and (x + xp >= 0):\n                        for yp in [-1, 0, 1]:\n                            if (y + yp < last_img.shape[1]) and (y + yp >= 0):\n                                i_xpyp = last_img[x + xp, y + yp]\n                                if i_xpyp > 0:\n\n                                    new_val = min(i_xy, i_xpyp, cur_img[x, y])\n                                    if cur_img[x, y] != new_val:\n                                        print(\n                                            (x, y),\n                                            i_xy,\n                                            \"vs\",\n                                            (x + xp, y + yp),\n                                            i_xpyp,\n                                            \"->\",\n                                            new_val,\n                                        )\n                                        cur_img[x, y] = new_val\n\n    img_list += [cur_img]\n    sns.heatmap(cur_img, annot=True, fmt=\"d\", cmap=\"nipy_spectral\", ax=c_ax)\n    c_ax.set_title(\"Iteration #{}\".format(iteration))\n    if (cur_img == last_img).all():\n        print(\"Done\")\n        break\n    else:\n        print(\n            \"Iteration\",\n            iteration,\n            \"Groups\",\n            len(np.unique(cur_img[cur_img > 0].ravel())),\n            \"Changes\",\n            np.sum(cur_img != last_img),\n        )\n        last_img = cur_img\n\n\n# The image very quickly converges and after 4 iterations the task is complete. For larger more complicated images with thousands of components this task can take longer, but there exist much more efficient [algorithms](https://www.cs.princeton.edu/~rs/AlgsDS07/01UnionFind.pdf) for labeling components which alleviate this issue.\n\n# In[9]:\n\n\nfrom matplotlib.animation import FuncAnimation\nfrom IPython.display import HTML\n\nfig, c_ax = plt.subplots(1, 1, figsize=(5, 5), dpi=150)\n\n\ndef update_frame(i):\n    plt.cla()\n    sns.heatmap(\n        img_list[i],\n        annot=True,\n        fmt=\"d\",\n        cmap=\"nipy_spectral\",\n        ax=c_ax,\n        cbar=False,\n        vmin=img_list[0].min(),\n        vmax=img_list[0].max(),\n    )\n    c_ax.set_title(\n        \"Iteration #{}, Groups {}\".format(\n            i + 1, len(np.unique(img_list[i][img_list[i] > 0].ravel()))\n        )\n    )\n\n\n# write animation frames\nanim_code = FuncAnimation(\n    fig, update_frame, frames=len(img_list) - 1, interval=1000, repeat_delay=2000\n).to_html5_video()\nplt.close(\"all\")\nHTML(anim_code)\n\n\n# # Bigger Images\n# How does the same algorithm apply to bigger images\n\n# In[10]:\n\n\nfrom skimage.io import imread\nfrom skimage.morphology import label\nimport seaborn as sns\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nseg_img = (imread(\"ext-figures/aachen_label.png\")[::4, ::4] == 26)[110:130:2, 370:420:3]\nseg_img[9, 1] = 1\n_, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 7), dpi=150)\nsns.heatmap(seg_img, annot=True, fmt=\"d\", ax=ax1, cmap=\"nipy_spectral\", cbar=False)\nidx_img = seg_img * np.arange(len(seg_img.ravel())).reshape(seg_img.shape)\nsns.heatmap(idx_img, annot=True, fmt=\"d\", ax=ax2, cmap=\"nipy_spectral\", cbar=False)\n\n\n# In[11]:\n\n\nlast_img = idx_img.copy()\nimg_list = [last_img]\nfor iteration in range(99):\n    cur_img = last_img.copy()\n    for x in range(last_img.shape[0]):\n        for y in range(last_img.shape[1]):\n            if last_img[x, y] > 0:\n                i_xy = last_img[x, y]\n                for xp in [-1, 0, 1]:\n                    if (x + xp < last_img.shape[0]) and (x + xp >= 0):\n                        for yp in [-1, 0, 1]:\n                            if (y + yp < last_img.shape[1]) and (y + yp >= 0):\n                                i_xpyp = last_img[x + xp, y + yp]\n                                if i_xpyp > 0:\n                                    new_val = min(i_xy, i_xpyp, cur_img[x, y])\n                                    if cur_img[x, y] != new_val:\n                                        cur_img[x, y] = new_val\n\n    img_list += [cur_img]\n    if (cur_img == last_img).all():\n        print(\"Done\")\n        break\n    else:\n        print(\n            \"Iteration\",\n            iteration,\n            \"Groups\",\n            len(np.unique(cur_img[cur_img > 0].ravel())),\n            \"Changes\",\n            np.sum(cur_img != last_img),\n        )\n        last_img = cur_img\n\n\n# In[12]:\n\n\nfrom matplotlib.animation import FuncAnimation\nfrom IPython.display import HTML\n\nfig, c_ax = plt.subplots(1, 1, figsize=(5, 5), dpi=150)\n\n\ndef update_frame(i):\n    plt.cla()\n    sns.heatmap(\n        img_list[i],\n        annot=True,\n        fmt=\"d\",\n        cmap=\"nipy_spectral\",\n        ax=c_ax,\n        cbar=False,\n        vmin=img_list[0].min(),\n        vmax=img_list[0].max(),\n    )\n    c_ax.set_title(\n        \"Iteration #{}, Groups {}\".format(\n            i + 1, len(np.unique(img_list[i][img_list[i] > 0].ravel()))\n        )\n    )\n\n\n# write animation frames\nanim_code = FuncAnimation(\n    fig, update_frame, frames=len(img_list) - 1, interval=500, repeat_delay=1000\n).to_html5_video()\nplt.close(\"all\")\nHTML(anim_code)\n\n\n# # Different Neighborhoods\n# We can expand beyond the 3x3 neighborhood to a 5x5 for example\n\n# In[13]:\n\n\nlast_img = idx_img.copy()\nimg_list = [last_img]\nfor iteration in range(99):\n    cur_img = last_img.copy()\n    for x in range(last_img.shape[0]):\n        for y in range(last_img.shape[1]):\n            if last_img[x, y] > 0:\n                i_xy = last_img[x, y]\n                for xp in [-2, -1, 0, 1, 2]:\n                    if (x + xp < last_img.shape[0]) and (x + xp >= 0):\n                        for yp in [-2, -1, 0, 1, 2]:\n                            if (y + yp < last_img.shape[1]) and (y + yp >= 0):\n                                i_xpyp = last_img[x + xp, y + yp]\n                                if i_xpyp > 0:\n                                    new_val = min(i_xy, i_xpyp, cur_img[x, y])\n                                    if cur_img[x, y] != new_val:\n                                        cur_img[x, y] = new_val\n\n    img_list += [cur_img]\n    if (cur_img == last_img).all():\n        print(\"Done\")\n        break\n    else:\n        print(\n            \"Iteration\",\n            iteration,\n            \"Groups\",\n            len(np.unique(cur_img[cur_img > 0].ravel())),\n            \"Changes\",\n            np.sum(cur_img != last_img),\n        )\n        last_img = cur_img\n\nfig, c_ax = plt.subplots(1, 1, figsize=(5, 5), dpi=150)\n\n\ndef update_frame(i):\n    plt.cla()\n    sns.heatmap(\n        img_list[i],\n        annot=True,\n        fmt=\"d\",\n        cmap=\"nipy_spectral\",\n        ax=c_ax,\n        cbar=False,\n        vmin=img_list[0].min(),\n        vmax=img_list[0].max(),\n    )\n    c_ax.set_title(\n        \"Iteration #{}, Groups {}\".format(\n            i + 1, len(np.unique(img_list[i][img_list[i] > 0].ravel()))\n        )\n    )\n\n\n# write animation frames\nanim_code = FuncAnimation(\n    fig, update_frame, frames=len(img_list) - 1, interval=500, repeat_delay=1000\n).to_html5_video()\nplt.close(\"all\")\nHTML(anim_code)\n\n\n# # Or a smaller kernel\n# By using a smaller kernel (in this case where $\\sqrt{x^2+y^2}<=1$, we cause the number of iterations to fill to increase and prevent the last pixel from being grouped since it is only connected diagonally\n#\n# |   |   |   |\n# |--:|--:|--:|\n# |  0|  1|  0|\n# |  1|  1|  1|\n# |  0|  1|  0|\n#\n\n# In[14]:\n\n\nlast_img = idx_img.copy()\nimg_list = [last_img]\nfor iteration in range(99):\n    cur_img = last_img.copy()\n    for x in range(last_img.shape[0]):\n        for y in range(last_img.shape[1]):\n            if last_img[x, y] > 0:\n                i_xy = last_img[x, y]\n                for xp in [-1, 0, 1]:\n                    if (x + xp < last_img.shape[0]) and (x + xp >= 0):\n                        for yp in [-1, 0, 1]:\n                            if np.abs(xp) + np.abs(yp) <= 1:\n                                if (y + yp < last_img.shape[1]) and (y + yp >= 0):\n                                    i_xpyp = last_img[x + xp, y + yp]\n                                    if i_xpyp > 0:\n                                        new_val = min(i_xy, i_xpyp, cur_img[x, y])\n                                        if cur_img[x, y] != new_val:\n                                            cur_img[x, y] = new_val\n\n    img_list += [cur_img]\n    if (cur_img == last_img).all():\n        print(\"Done\")\n        break\n    else:\n        print(\n            \"Iteration\",\n            iteration,\n            \"Groups\",\n            len(np.unique(cur_img[cur_img > 0].ravel())),\n            \"Changes\",\n            np.sum(cur_img != last_img),\n        )\n        last_img = cur_img\n\nfig, c_ax = plt.subplots(1, 1, figsize=(6, 6), dpi=100)\n\n\ndef update_frame(i):\n    plt.cla()\n    sns.heatmap(\n        img_list[i],\n        annot=True,\n        fmt=\"d\",\n        cmap=\"nipy_spectral\",\n        ax=c_ax,\n        cbar=False,\n        vmin=img_list[0].min(),\n        vmax=img_list[0].max(),\n    )\n    c_ax.set_title(\n        \"Iteration #{}, Groups {}\".format(\n            i + 1, len(np.unique(img_list[i][img_list[i] > 0].ravel()))\n        )\n    )\n\n\n# write animation frames\nanim_code = FuncAnimation(\n    fig, update_frame, frames=len(img_list) - 1, interval=500, repeat_delay=1000\n).to_html5_video()\nplt.close(\"all\")\nHTML(anim_code)\n\n\n# # Component Labeling: Beyond\n#\n#\n# Now all the voxels which are connected have the same label. We can then perform simple metrics like\n#\n# - counting the number of voxels in each label to estimate volume.\n# - looking at the change in volume during erosion or dilation to estimate surface area\n\n# ### What we would like to to do\n#\n# - Count the cells\n# - Say something about the cells\n# - Compare the cells in this image to another image\n# - But where do we start?\n#\n# # COV: With a single object\n#\n# $$ I_{id}(x,y) =\n# \\begin{cases}\n# 1, & L(x,y) = id \\\\\n# 0, & \\text{otherwise}\n# \\end{cases}$$\n\n# In[15]:\n\n\nfrom IPython.display import Markdown\nfrom skimage.io import imread\nfrom skimage.morphology import label\nimport seaborn as sns\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nseg_img = imread(\"ext-figures/aachen_label.png\") == 26\nseg_img = seg_img[::4, ::4]\nseg_img = seg_img[110:130:2, 370:420:3]\nseg_img[9, 1] = 1\nlab_img = label(seg_img)\n_, (ax1) = plt.subplots(1, 1, figsize=(7, 7), dpi=150)\nsns.heatmap(lab_img, annot=True, fmt=\"d\", ax=ax1, cmap=\"nipy_spectral\", cbar=False)\n\n\n# ### Define a center\n# $$ \\bar{x} = \\frac{1}{N} \\sum_{\\vec{v}\\in I_{id}} \\vec{v}\\cdot\\vec{i} $$\n# $$ \\bar{y} = \\frac{1}{N} \\sum_{\\vec{v}\\in I_{id}} \\vec{v}\\cdot\\vec{j} $$\n# $$ \\bar{z} = \\frac{1}{N} \\sum_{\\vec{v}\\in I_{id}} \\vec{v}\\cdot\\vec{k} $$\n#\n\n# In[16]:\n\n\nx_coord, y_coord = [], []\nfor x in range(seg_img.shape[0]):\n    for y in range(seg_img.shape[1]):\n        if seg_img[x, y] == 1:\n            x_coord += [x]\n            y_coord += [y]\nprint(\"x,y coordinates\", list(zip(x_coord, y_coord)))\nMarkdown(\"$\\\\bar{x} = %2.2f, \\\\bar{y} = %2.2f $\" % (np.mean(x_coord), np.mean(y_coord)))\n\n\n# # COM: With a single object\n#\n# If the gray values are kept (or other meaningful ones are used), this can be seen as a weighted center of volume or center of mass (using $I_{gy}$ to distinguish it from the labels)\n#\n# ### Define a center\n# $$ \\Sigma I_{gy} = \\frac{1}{N} \\sum_{\\vec{v}\\in I_{id}} I_{gy}(\\vec{v}) $$\n# $$ \\bar{x} = \\frac{1}{\\Sigma I_{gy}} \\sum_{\\vec{v}\\in I_{id}} (\\vec{v}\\cdot\\vec{i}) I_{gy}(\\vec{v}) $$\n# $$ \\bar{y} = \\frac{1}{\\Sigma I_{gy}} \\sum_{\\vec{v}\\in I_{id}} (\\vec{v}\\cdot\\vec{j}) I_{gy}(\\vec{v}) $$\n# $$ \\bar{z} = \\frac{1}{\\Sigma I_{gy}} \\sum_{\\vec{v}\\in I_{id}} (\\vec{v}\\cdot\\vec{k}) I_{gy}(\\vec{v}) $$\n#\n\n# In[17]:\n\n\nfrom IPython.display import Markdown, display\nimport seaborn as sns\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nxx, yy = np.meshgrid(np.linspace(0, 10, 50), np.linspace(0, 10, 50))\ngray_img = 100 * (np.abs(xx * yy - 7) + np.square(yy - 4)) + 0.25\ngray_img *= np.abs(xx - 5) < 3\ngray_img *= np.abs(yy - 5) < 3\ngray_img[gray_img > 0] += 5\nseg_img = (gray_img > 0).astype(int)\n_, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 7), dpi=150)\n\nsns.heatmap(gray_img, ax=ax1, cmap=\"bone_r\", cbar=True)\nax1.set_title(\"Intensity Image\")\n\nsns.heatmap(seg_img, ax=ax2, cmap=\"bone\", cbar=False)\nax2.set_title(\"Segmented Image\")\n\n\n# In[18]:\n\n\nx_coord, y_coord, i_val = [], [], []\nfor x in range(seg_img.shape[0]):\n    for y in range(seg_img.shape[1]):\n        if seg_img[x, y] == 1:\n            x_coord += [x]\n            y_coord += [y]\n            i_val += [gray_img[x, y]]\n\nx_coord = np.array(x_coord)\ny_coord = np.array(y_coord)\ni_val = np.array(i_val)\ncov_x = np.mean(x_coord)\ncov_y = np.mean(y_coord)\n\ndisplay(\n    Markdown(\n        \"\"\"## Center of Volume: \n- $\\\\bar{x} = %2.2f$\n- $\\\\bar{y} = %2.2f $\"\"\"\n        % (cov_x, cov_y)\n    )\n)\n\ncom_x = np.sum(x_coord * i_val) / np.sum(i_val)\ncom_y = np.sum(y_coord * i_val) / np.sum(i_val)\n\ndisplay(\n    Markdown(\n        \"\"\"## Center of Mass: \n- $\\\\bar{x}_m = %2.2f$\n- $\\\\bar{y}_m = %2.2f $\"\"\"\n        % (com_x, com_y)\n    )\n)\n\n_, (ax1) = plt.subplots(1, 1, figsize=(7, 7), dpi=150)\n\nax1.matshow(gray_img, cmap=\"bone_r\")\nax1.set_title(\"Intensity Image\")\nax1.plot([cov_y], [cov_x], \"ro\", label=\"COV\", markersize=20)\nax1.plot([com_y], [com_x], \"bo\", label=\"COM\", markersize=20)\nax1.legend()\n\n\n# In[19]:\n\n\nfrom skimage.measure import regionprops\n\nhelp(regionprops)\n\n\n# In[20]:\n\n\nfrom skimage.measure import regionprops\n\nall_regs = regionprops(seg_img, intensity_image=gray_img)\nfor c_reg in all_regs:\n    display(Markdown(\"# Region: {}\".format(c_reg.label)))\n    for k in dir(c_reg):\n        if not k.startswith(\"_\") and (\"image\" not in k):\n            display(Markdown(\"- {} {}\".format(k, getattr(c_reg, k))))\n\n\n# # Extents: With a single object\n#\n# Exents or caliper lenghts are the size of the object in a given direction. Since the coordinates of our image our $x$ and $y$ the extents are calculated in these directions\n#\n# Define extents as the minimum and maximum values along the projection of the shape in each direction\n# $$ \\text{Ext}_x = \\left\\{ \\forall \\vec{v}\\in I_{id}: max(\\vec{v}\\cdot\\vec{i})-min(\\vec{v}\\cdot\\vec{i})  \\right\\} $$\n# $$ \\text{Ext}_y = \\left\\{ \\forall \\vec{v}\\in I_{id}: max(\\vec{v}\\cdot\\vec{j})-min(\\vec{v}\\cdot\\vec{j})  \\right\\} $$\n# $$ \\text{Ext}_z = \\left\\{ \\forall \\vec{}\\in I_{id}: max(\\vec{v}\\cdot\\vec{k})-min(\\vec{v}\\cdot\\vec{k})  \\right\\} $$\n#\n# - Lots of information about each object now\n# - But, I don't think a biologist has ever asked \"How long is a cell in the $x$ direction? how about $y$?\"\n\n# In[21]:\n\n\nfrom IPython.display import Markdown\nfrom skimage.io import imread\nfrom skimage.morphology import label\nimport seaborn as sns\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nseg_img = imread(\"ext-figures/aachen_label.png\") == 26\nseg_img = seg_img[::4, ::4]\nseg_img = seg_img[110:130:2, 378:420:3] > 0\nseg_img = np.pad(seg_img, 3, mode=\"constant\")\n_, (ax1) = plt.subplots(1, 1, figsize=(7, 7), dpi=150)\nax1.matshow(seg_img, cmap=\"bone_r\")\n\n\n# In[22]:\n\n\nx_coord, y_coord = [], []\nfor x in range(seg_img.shape[0]):\n    for y in range(seg_img.shape[1]):\n        if seg_img[x, y] == 1:\n            x_coord += [x]\n            y_coord += [y]\nxmin = np.min(x_coord)\nxmax = np.max(x_coord)\nymin = np.min(y_coord)\nymax = np.max(y_coord)\nprint(\"X -> \", \"Min:\", xmin, \"Max:\", xmax)\nprint(\"Y -> \", \"Min:\", ymin, \"Max:\", ymax)\n\n\n# In[23]:\n\n\nfrom matplotlib.collections import PatchCollection\nfrom matplotlib.patches import Rectangle\n\n_, (ax1) = plt.subplots(1, 1, figsize=(7, 7), dpi=150)\n\nax1.matshow(seg_img, cmap=\"bone_r\")\n\nxw = xmax - xmin\nyw = ymax - ymin\n\nc_bbox = [Rectangle(xy=(ymin, xmin), width=yw, height=xw)]\nc_bb_patch = PatchCollection(\n    c_bbox, facecolor=\"none\", edgecolor=\"red\", linewidth=4, alpha=0.5\n)\nax1.add_collection(c_bb_patch)\n\n\n# # Concrete Example\n# So how can we begin to apply the tools we have developed. We take the original car scene from before.\n\n# In[24]:\n\n\nfrom skimage.measure import regionprops, label\nfrom skimage.io import imread\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\ncar_img = np.clip(imread(\"ext-figures/aachen_img.png\")[75:150] * 2.0, 0, 255).astype(\n    np.uint8\n)\nlab_img = label(imread(\"ext-figures/aachen_label.png\")[::4, ::4] == 26)[75:150]\nfig, (ax1, ax2) = plt.subplots(2, 1, figsize=(20, 8))\nax1.imshow(car_img)\nax1.set_title(\"Input Image\")\n\nplt.colorbar(ax2.imshow(lab_img, cmap=\"nipy_spectral\"))\nax2.set_title(\"Labeled Image\")\n\n\n# # Shape Analysis\n# We can perform shape analysis on the image and calculate basic shape parameters for each object\n\n# In[25]:\n\n\nfrom skimage.measure import regionprops\nfrom matplotlib.patches import Rectangle\nfrom matplotlib.collections import PatchCollection\n\n# shape analysis\nall_regions = regionprops(lab_img)\n\nfig, ax1 = plt.subplots(1, 1, figsize=(12, 6), dpi=100)\nax1.imshow(car_img)\nprint(\"Found \", len(all_regions), \"regions\")\nbbox_list = []\nfor c_reg in all_regions:\n    ax1.plot(c_reg.centroid[1], c_reg.centroid[0], \"o\", markersize=5)\n    bbox_list += [\n        Rectangle(\n            xy=(c_reg.bbox[1], c_reg.bbox[0]),\n            width=c_reg.bbox[3] - c_reg.bbox[1],\n            height=c_reg.bbox[2] - c_reg.bbox[0],\n        )\n    ]\nc_bb_patch = PatchCollection(\n    bbox_list, facecolor=\"none\", edgecolor=\"red\", linewidth=4, alpha=0.5\n)\nax1.add_collection(c_bb_patch)\n\n\n# # Statistics\n# We can then generate a table full of these basic parameters for each object. In this case, we add color as an additional description\n\n# In[26]:\n\n\nfrom sklearn.neighbors import KNeighborsClassifier\nimport webcolors\nimport pandas as pd\nfrom skimage.morphology import erosion, disk\n\n\ndef ed_img(in_img):\n    # shrink an image to a few pixels\n    cur_img = in_img.copy()\n    while cur_img.max() > 0:\n        last_img = cur_img\n        cur_img = erosion(cur_img, disk(1))\n    return last_img\n\n\n# guess color name based on rgb value\ncolor_name_class = KNeighborsClassifier(1)\nc_names = sorted(webcolors.css3_names_to_hex.keys())\ncolor_name_class.fit([tuple(webcolors.name_to_rgb(k)) for k in c_names], c_names)\n\n\nreg_df = pd.DataFrame(\n    [\n        dict(\n            label=c_reg.label,\n            bbox=c_reg.bbox,\n            area=c_reg.area,\n            centroid=c_reg.centroid,\n            color=color_name_class.predict(\n                np.mean(car_img[ed_img(lab_img == c_reg.label)], 0)[:3].reshape((1, -1))\n            )[0],\n        )\n        for c_reg in all_regions\n    ]\n)\nfig, m_axs = plt.subplots(len(all_regions), 1, figsize=(3, 14))\nfor c_ax, c_reg in zip(m_axs, all_regions):\n    c_ax.imshow(car_img[c_reg.bbox[0] : c_reg.bbox[2], c_reg.bbox[1] : c_reg.bbox[3]])\n    c_ax.axis(\"off\")\n    c_ax.set_title(\"Label {}\".format(c_reg.label))\nreg_df\n\n\n# Anisotropy: What is it?\n# ===\n# By definition (New Oxford American): ```varying in magnitude according to the direction of measurement.```\n#\n# - It allows us to define metrics in respect to one another and thereby characterize shape.\n# - Is it tall and skinny, short and fat, or perfectly round\n#\n# ***\n#\n# Due to its very vague definition, it can be mathematically characterized in many different very much unequal ways (in all cases 0 represents a sphere)\n#\n# $$ Aiso1 = \\frac{\\text{Longest Side}}{\\text{Shortest Side}} - 1 $$\n#\n# $$ Aiso2 = \\frac{\\text{Longest Side}-\\text{Shortest Side}}{\\text{Longest Side}} $$\n#\n# $$ Aiso3 = \\frac{\\text{Longest Side}}{\\text{Average Side Length}} - 1 $$\n#\n# $$ Aiso4 = \\frac{\\text{Longest Side}-\\text{Shortest Side}}{\\text{Average Side Length}} $$\n#\n# $$ \\cdots \\rightarrow \\text{ ad nauseum} $$\n\n# In[27]:\n\n\nfrom collections import defaultdict\nfrom skimage.measure import regionprops\nimport seaborn as sns\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nxx, yy = np.meshgrid(np.linspace(-5, 5, 100), np.linspace(-5, 5, 100))\n\n\ndef side_len(c_reg):\n    return sorted([c_reg.bbox[3] - c_reg.bbox[1], c_reg.bbox[2] - c_reg.bbox[0]])\n\n\naiso_funcs = [\n    lambda x: side_len(x)[-1] / side_len(x)[0] - 1,\n    lambda x: (side_len(x)[-1] - side_len(x)[0]) / side_len(x)[-1],\n    lambda x: side_len(x)[-1] / np.mean(side_len(x)) - 1,\n    lambda x: (side_len(x)[-1] - side_len(x)[0]) / np.mean(side_len(x)),\n]\n\n\ndef ell_func(a, b):\n    return np.sqrt(np.square(xx / a) + np.square(yy / b)) <= 1\n\n\n# In[28]:\n\n\nfrom matplotlib.animation import FuncAnimation\nfrom IPython.display import HTML\n\nfig, m_axs = plt.subplots(2, 3, figsize=(12, 10), dpi=120)\nab_list = [\n    (2, 2),\n    (2, 3),\n    (2, 4),\n    (2, 5),\n    (1.5, 5),\n    (1, 5),\n    (0.5, 5),\n    (0.1, 5),\n    (0.05, 5),\n]\nfunc_pts = defaultdict(list)\n\n\ndef update_frame(i):\n    plt.cla()\n    a, b = ab_list[i]\n    c_img = ell_func(a, b)\n    m_axs[0, 0].imshow(c_img, cmap=\"gist_earth\")\n    reg_info = regionprops(c_img.astype(int))[0]\n    m_axs[0, 0].set_title(\"Shape #{}\".format(i + 1))\n    for j, (c_func, c_ax) in enumerate(zip(aiso_funcs, m_axs.flatten()[1:]), 1):\n        func_pts[j] += [c_func(reg_info)]\n        c_ax.plot(func_pts[j], \"r-\")\n        c_ax.set_title(\"Anisotropy #{}\".format(j))\n        c_ax.set_ylim(-0.1, 3)\n    m_axs.flatten()[-1].axis(\"off\")\n\n\n# write animation frames\nanim_code = FuncAnimation(\n    fig, update_frame, frames=len(ab_list) - 1, interval=500, repeat_delay=1000\n).to_html5_video()\nplt.close(\"all\")\nHTML(anim_code)\n\n\n# # Useful Statistical Tools: Principal Component Analysis\n#\n# While many of the topics covered in Linear Algebra and Statistics courses might not seem very applicable to real problems at first glance, at least a few of them come in handy for dealing distributions of pixels _(they will only be briefly covered, for more detailed review look at some of the suggested material)_\n#\n# ### Principal Component Analysis\n# Similar to K-Means insofar as we start with a series of points in a vector space and want to condense the information. With PCA instead of searching for distinct groups, we try to find a linear combination of components which best explain the variance in the system.\n#\n# ***\n#\n# As an example we will use a very simple example from spectroscopy\n\n# In[29]:\n\n\nimport pandas as pd\nimport seaborn as sns\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\ncm_dm = np.linspace(1000, 4000, 300)\n\n\ndef peak(cent, wid, h):\n    return h / (wid * np.sqrt(2 * np.pi)) * np.exp(-np.square((cm_dm - cent) / wid))\n\n\ndef peaks(plist):\n    return np.sum(\n        np.stack([peak(cent, wid, h) for cent, wid, h in plist], 0), 0\n    ) + np.random.uniform(0, 1, size=cm_dm.shape)\n\n\nfat_curve = [(2900, 100, 500), (1680, 200, 400)]\nprotein_curve = [(2900, 50, 200), (3400, 100, 600), (1680, 200, 300)]\nnoise_curve = [(3000, 50, 1)]\n\nfig, (ax0, ax1, ax2) = plt.subplots(1, 3, figsize=(12, 6))\n\nax1.plot(cm_dm, peaks(fat_curve))\nax1.set_title(\"Fat IR Spectra\")\n\nax2.plot(cm_dm, peaks(protein_curve))\nax2.set_title(\"Protein IR Spectra\")\n\nax0.plot(cm_dm, peaks(noise_curve))\nax0.set_title(\"Noise IR Spectra\")\n\nax0.set_ylim(ax2.get_ylim())\nax2.set_ylim(ax2.get_ylim())\n\npd.DataFrame({\"cm^(-1)\": cm_dm, \"intensity\": peaks(protein_curve)}).head(10)\n\n\n# # Test Dataset of a number of curves\n# We want to sort cells or samples into groups of being more fat like or more protein like.\n#\n# ## How can we analyze this data without specifically looking for peaks or building models?\n\n# In[30]:\n\n\ntest_data = np.stack(\n    [\n        peaks(c_curve)\n        for _ in range(20)\n        for c_curve in [protein_curve, fat_curve, noise_curve]\n    ],\n    0,\n)\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))\n\nax1.plot(test_data[:4].T, \".-\")\nax1.legend([\"Curve 1\", \"Curve 2\", \"Curve 3\", \"Curve 4\"])\nax2.scatter(\n    test_data[:, 0],\n    test_data[:, 1],\n    c=range(test_data.shape[0]),\n    s=20,\n    cmap=\"nipy_spectral\",\n)\n\n\n# In[31]:\n\n\nfrom sklearn.decomposition import PCA\n\npca_tool = PCA(5)\npca_tool.fit(test_data)\n\n\n# # Useful Statistical Tools: Principal Component Analysis\n#\n# The first principal component provides\n#\n# The second principal component is then related to the unique information seperating chicken from corn prices but neither indices directly themselves (maybe the cost of antibiotics)\n\n# In[32]:\n\n\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))\nscore_matrix = pca_tool.transform(test_data)\nax1.plot(cm_dm, pca_tool.components_[0, :], label=\"Component #1\")\nax1.plot(\n    cm_dm,\n    pca_tool.components_[1, :],\n    label=\"Component #2\",\n    alpha=pca_tool.explained_variance_ratio_[0],\n)\nax1.plot(\n    cm_dm,\n    pca_tool.components_[2, :],\n    label=\"Component #3\",\n    alpha=pca_tool.explained_variance_ratio_[1],\n)\nax1.legend()\nax2.scatter(score_matrix[:, 0], score_matrix[:, 1])\nax2.set_xlabel(\"Component 1\")\nax2.set_ylabel(\"Component 2\")\n\n\n# In[33]:\n\n\nfig, ax1 = plt.subplots(1, 1, figsize=(8, 4), dpi=120)\nax1.bar(\n    x=range(pca_tool.explained_variance_ratio_.shape[0]),\n    height=100 * pca_tool.explained_variance_ratio_,\n)\nax1.set_xlabel(\"Components\")\nax1.set_ylabel(\"Explained Variance (%)\")\n\n\n# # Principal Component Analysis\n# ## scikit-learn [Face Analyis](http://scikit-learn.org/stable/auto_examples/decomposition/plot_faces_decomposition.html)\n#\n# Here we show a more imaging related example from the scikit-learn documentation where we do basic face analysis with scikit-learn.\n#\n\n# In[34]:\n\n\nfrom sklearn.datasets import fetch_olivetti_faces\nfrom sklearn import decomposition\n\n# Load faces data\ntry:\n    dataset = fetch_olivetti_faces(shuffle=True, random_state=2018, data_home=\".\")\n    faces = dataset.data\nexcept Exception as e:\n    print(\"Face data not available\", e)\n    faces = np.random.uniform(0, 1, (400, 4096))\n\nn_samples, n_features = faces.shape\nn_row, n_col = 2, 3\nn_components = n_row * n_col\nimage_shape = (64, 64)\n\n# global centering\nfaces_centered = faces - faces.mean(axis=0)\n\n# local centering\nfaces_centered -= faces_centered.mean(axis=1).reshape(n_samples, -1)\n\nprint(\"Dataset consists of %d faces\" % n_samples)\n\n\n# In[35]:\n\n\ndef plot_gallery(title, images, n_col=n_col, n_row=n_row):\n    plt.figure(figsize=(2.0 * n_col, 2.26 * n_row))\n    plt.suptitle(title, size=16)\n    for i, comp in enumerate(images):\n        plt.subplot(n_row, n_col, i + 1)\n        vmax = max(comp.max(), -comp.min())\n        plt.imshow(\n            comp.reshape(image_shape),\n            cmap=plt.cm.gray,\n            interpolation=\"nearest\",\n            vmin=-vmax,\n            vmax=vmax,\n        )\n        plt.xticks(())\n        plt.yticks(())\n    plt.subplots_adjust(0.01, 0.05, 0.99, 0.93, 0.04, 0.0)\n\n\n# #############################################################################\n# List of the different estimators, whether to center and transpose the\n# problem, and whether the transformer uses the clustering API.\nestimators = [\n    (\n        \"Eigenfaces - PCA using randomized SVD\",\n        decomposition.PCA(\n            n_components=n_components, svd_solver=\"randomized\", whiten=True\n        ),\n        True,\n    )\n]\n# #############################################################################\n# Plot a sample of the input data\n\nplot_gallery(\"First centered Olivetti faces\", faces_centered[:n_components])\n\n# #############################################################################\n# Do the estimation and plot it\n\nfor name, estimator, center in estimators:\n    print(\"Extracting the top %d %s...\" % (n_components, name))\n    data = faces\n    if center:\n        data = faces_centered\n    estimator.fit(data)\n\n    if hasattr(estimator, \"cluster_centers_\"):\n        components_ = estimator.cluster_centers_\n    else:\n        components_ = estimator.components_\n    plot_gallery(name, components_[:n_components])\n\nplt.show()\n\n\n# # Applied PCA: Shape Tensor\n#\n# ## How do these statistical analyses help us?\n# Going back to a single cell, we have the a distribution of $x$ and $y$ values.\n# - are not however completely independent\n# - greatest variance does not normally lie in either x nor y alone.\n#\n# A principal component analysis of the voxel positions, will calculate two new principal components (the components themselves are the relationships between the input variables and the scores are the final values.)\n# - An optimal rotation of the coordinate system\n\n# We start off by calculating the covariance matrix from the list of $x$, $y$, and $z$ points that make up our object of interest.\n#\n# $$ COV(I_{id}) = \\frac{1}{N} \\sum_{\\forall\\vec{v}\\in I_{id}} \\begin{bmatrix}\n# \\vec{v}_x\\vec{v}_x & \\vec{v}_x\\vec{v}_y & \\vec{v}_x\\vec{v}_z\\\\\n# \\vec{v}_y\\vec{v}_x & \\vec{v}_y\\vec{v}_y & \\vec{v}_y\\vec{v}_z\\\\\n# \\vec{v}_z\\vec{v}_x & \\vec{v}_z\\vec{v}_y & \\vec{v}_z\\vec{v}_z\n# \\end{bmatrix} $$\n#\n# We then take the eigentransform of this array to obtain the eigenvectors (principal components, $\\vec{\\Lambda}_{1\\cdots 3}$) and eigenvalues (scores, $\\lambda_{1\\cdots 3}$)\n#\n# $$ COV(I_{id}) \\longrightarrow \\underbrace{\\begin{bmatrix}\n# \\vec{\\Lambda}_{1x} & \\vec{\\Lambda}_{1y} & \\vec{\\Lambda}_{1z} \\\\\n# \\vec{\\Lambda}_{2x} & \\vec{\\Lambda}_{2y} & \\vec{\\Lambda}_{2z} \\\\\n# \\vec{\\Lambda}_{3x} & \\vec{\\Lambda}_{3y} & \\vec{\\Lambda}_{3z}\n# \\end{bmatrix}}_{\\textrm{Eigenvectors}} * \\underbrace{\\begin{bmatrix}\n# \\lambda_1 & 0 & 0 \\\\\n# 0 & \\lambda_2 & 0 \\\\\n# 0 & 0 & \\lambda_3\n# \\end{bmatrix}}_{\\textrm{Eigenvalues}} * \\underbrace{\\begin{bmatrix}\n# \\vec{\\Lambda}_{1x} & \\vec{\\Lambda}_{1y} & \\vec{\\Lambda}_{1z} \\\\\n# \\vec{\\Lambda}_{2x} & \\vec{\\Lambda}_{2y} & \\vec{\\Lambda}_{2z} \\\\\n# \\vec{\\Lambda}_{3x} & \\vec{\\Lambda}_{3y} & \\vec{\\Lambda}_{3z}\n# \\end{bmatrix}^{T}}_{\\textrm{Eigenvectors}} $$\n# The principal components tell us about the orientation of the object and the scores tell us about the corresponding magnitude (or length) in that direction.\n\n# In[36]:\n\n\nfrom IPython.display import Markdown\nfrom skimage.io import imread\nfrom skimage.morphology import label\nimport seaborn as sns\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nseg_img = imread(\"ext-figures/aachen_label.png\") == 26\nseg_img = seg_img[::4, ::4]\nseg_img = seg_img[110:130:2, 378:420:3] > 0\nseg_img = np.pad(seg_img, 3, mode=\"constant\")\nseg_img[0, 0] = 0\n_, (ax1) = plt.subplots(1, 1, figsize=(7, 7), dpi=150)\nax1.matshow(seg_img, cmap=\"bone_r\")\n\n\n# In[37]:\n\n\nfrom sklearn.decomposition import PCA\n\nx_coord, y_coord = np.where(seg_img > 0)\nxy_pts = np.stack([x_coord, y_coord], 1)\nshape_pca = PCA()\nshape_pca.fit(xy_pts)\npca_xy_vals = shape_pca.transform(xy_pts)\n_, (ax1) = plt.subplots(1, 1, figsize=(7, 7), dpi=150)\nax1.plot(pca_xy_vals[:, 0], pca_xy_vals[:, 1], \"rs\", markersize=10)\n\n\n# In[38]:\n\n\n_, (ax1) = plt.subplots(1, 1, figsize=(7, 7), dpi=150)\n\n\nax1.plot(\n    xy_pts[:, 0] - np.mean(xy_pts[:, 0]),\n    xy_pts[:, 1] - np.mean(xy_pts[:, 1]),\n    \"rs\",\n    label=\"Points\",\n)\nax1.plot(\n    [0, shape_pca.explained_variance_[0] / 2 * shape_pca.components_[0, 0]],\n    [0, shape_pca.explained_variance_[0] / 2 * shape_pca.components_[0, 1]],\n    \"b-\",\n    label=\"PCA1\",\n)\nax1.plot(\n    [0, shape_pca.explained_variance_[1] / 2 * shape_pca.components_[1, 0]],\n    [0, shape_pca.explained_variance_[1] / 2 * shape_pca.components_[1, 1]],\n    \"g-\",\n    label=\"PCA2\",\n)\nax1.legend()\n\n\n# # Principal Component Analysis: Take home message\n#\n# - We calculate the statistical distribution individually for $x$, $y$, and $z$ and the 'correlations' between them.\n# - From these values we can estimate the orientation in the direction of largest variance\n# - We can also estimate magnitude\n# - These functions are implemented as ```princomp``` or ```pca``` in various languages and scale well to very large datasets.\n\n# # Principal Component Analysis: Elliptical Model\n#\n#\n# While the eigenvalues and eigenvectors are in their own right useful\n# - Not obvious how to visually represent these tensor objects\n# - Ellipsoidal (Ellipse in 2D) representation alleviates this issue\n#\n# ### Ellipsoidal Representation\n# 1. Center of Volume is calculated normally\n# 1. Eigenvectors represent the unit vectors for the semiaxes of the ellipsoid\n# 1. $\\sqrt{\\text{Eigenvalues}}$ is proportional to the length of the semiaxis ($\\mathcal{l}=\\sqrt{5\\lambda_i}$), derivation similar to moment of inertia tensor for ellipsoids.\n#\n# ***\n\n# # Meshing\n#\n#\n# Constructing a mesh for an image provides very different information than the image data itself. Most crucially this comes when looking at physical processes like deformation.\n#\n# While the images are helpful for visualizing we rarely have models for quantifying how difficult it is to turn a pixel __off__\n#\n# If the image is turned into a mesh we now have a list of vertices and edges. For these vertices and edges we can define forces. For example when looking at stress-strain relationships in mechanics using Hooke's Model\n# $$ \\vec{F}=k (\\vec{x}_0-\\vec{x}) $$\n# the force needed to stretch one of these edges is proportional to how far it is stretched.\n\n# # Meshing\n#\n#\n# Since we uses voxels to image and identify the volume we can use the voxels themselves as an approimation for the surface of the structure.\n# - Each 'exposed' face of a voxel belongs to the surface\n#\n# From this we can create a mesh by\n#\n# - adding each exposed voxel face to a list of surface squares.\n# - adding connectivity information for the different squares (shared edges and vertices)\n#\n# A wide variety of methods of which we will only graze the surface (http://en.wikipedia.org/wiki/Image-based_meshing)\n\n# # Marching Cubes\n#\n# ### Why\n# Voxels are very poor approximations for the surface and are very rough (they are either normal to the x, y, or z axis and nothing between). Because of their inherently orthogonal surface normals, any analysis which utilizes the surface normal to calculate another value (growth, curvature, etc) is going to be very inaccurate at best and very wrong at worst.\n#\n# ### [How](https://en.wikipedia.org/wiki/Marching_cubes)\n# The image is processed one voxel at a time and the neighborhood (not quite the same is the morphological definition) is checked at every voxel. From this configuration of values, faces are added to the mesh to incorporate the most simple surface which would explain the values.\n#\n# [Marching tetrahedra](http://en.wikipedia.org/wiki/Marching_tetrahedra) is for some applications a better suited approach\n\n# # Next Time on QBI\n#\n#\n# So while bounding box and ellipse-based models are useful for many object and cells, they do a very poor job with other samples\n#\n#\n# ***\n#\n# ### Why\n# - We assume an entity consists of connected pixels (wrong)\n# - We assume the objects are well modeled by an ellipse (also wrong)\n#\n# ### What to do?\n#\n# - Is it 3 connected objects which should all be analzed seperately?\n# - If we could __divide it__, we could then analyze each spart as an ellipse\n# - Is it one network of objects and we want to know about the constrictions?\n# - Is it a cell or organelle with docking sites for cell?\n# - Neither extents nor anisotropy are very meaningful, we need a __more specific metric__ which can characterize\n\n# In[ ]:\n", "meta": {"hexsha": "0a921cab92da29375a894482feadbd3c8f34fcfd", "size": 41585, "ext": "py", "lang": "Python", "max_stars_repo_path": "Lectures/06-ShapeAnalysis.py", "max_stars_repo_name": "kmader/qbi-2019-py", "max_stars_repo_head_hexsha": "25ca789cc35e02ac02eaa5e1943093ef55c096a5", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-11-06T16:20:50.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-11T03:38:02.000Z", "max_issues_repo_path": "Lectures/06-ShapeAnalysis.py", "max_issues_repo_name": "kmader/qbi-2019-py", "max_issues_repo_head_hexsha": "25ca789cc35e02ac02eaa5e1943093ef55c096a5", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-11-06T16:41:39.000Z", "max_issues_repo_issues_event_max_datetime": "2019-11-07T13:02:17.000Z", "max_forks_repo_path": "Lectures/06-ShapeAnalysis.py", "max_forks_repo_name": "kmader/qbi-2019-py", "max_forks_repo_head_hexsha": "25ca789cc35e02ac02eaa5e1943093ef55c096a5", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-04-09T10:43:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-09T10:43:55.000Z", "avg_line_length": 30.0686912509, "max_line_length": 360, "alphanum_fraction": 0.6305879524, "include": true, "reason": "import numpy", "num_tokens": 11983, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4416730056646256, "lm_q2_score": 0.21206880435710534, "lm_q1q2_score": 0.09366506622810616}}
{"text": "# -*- coding: utf-8 -*-\n# ---\n# jupyter:\n#   jupytext:\n#     formats: ipynb,py:light\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.4'\n#       jupytext_version: 1.2.4\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# + {\"colab_type\": \"text\", \"id\": \"6Tmmlr92MZVj\", \"slideshow\": {\"slide_type\": \"slide\"}, \"cell_type\": \"markdown\"}\n# # Probabilistic Programming and Bayesian Methods for Hackers Chapter 1\n#\n# <table class=\"tfo-notebook-buttons\" align=\"left\">\n#   <td>\n#     <a target=\"_blank\" href=\"https://colab.research.google.com/github/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter1_Introduction/Ch1_Introduction_TFP.ipynb\"><img height=\"32px\" src=\"https://colab.research.google.com/img/colab_favicon.ico\" />Run in Google Colab</a>\n#   </td>\n#   <td>\n#     <a target=\"_blank\" href=\"https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter1_Introduction/Ch1_Introduction_TFP.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n#   </td>\n# </table>\n# <br>\n# <br>\n# <br>\n#\n# Original content ([this Jupyter notebook](https://nbviewer.jupyter.org/github/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter1_Introduction/Ch1_Introduction_PyMC2.ipynb)) created by Cam Davidson-Pilon ([`@Cmrn_DP`](https://twitter.com/Cmrn_DP))\n#\n# Ported to [Tensorflow Probability](https://www.tensorflow.org/probability/) by Matthew McAteer ([`@MatthewMcAteer0`](https://twitter.com/MatthewMcAteer0)) and Bryan Seybold, with help from the TFP team at  Google ([`tfprobability@tensorflow.org`](mailto:tfprobability@tensorflow.org)).\n#\n# Welcome to Bayesian Methods for Hackers. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n#\n# ---\n# ### Table of Contents\n# - Dependencies & Prerequisites\n# - The Philosophy of Bayesian Inference\n# - The Bayesian state of mind\n# - Bayesian Inference in Practice\n# - Are frequentist methods incorrect then?\n# - Our Bayesian framework\n# - Example: Mandatory coin-flip example\n# - Example: Bug, or just sweet, unintended feature?\n# - Probability Distributions\n#   - Discrete Case\n# - Continuous Case\n# - But what is $\\lambda \\;$?\n#   - Example: Inferring behaviour from text-message data\n# - Introducing our first hammer: Tensorflow Probability\n# - specify the joint log-density\n# - Specify the posterior sampler\n# - Execute the TF graph to sample from the posterior\n# - Plot the Results\n# - Interpretation\n# - Exercises\n# - References\n\n# + {\"colab_type\": \"text\", \"id\": \"YcJ8nEDVH30J\", \"cell_type\": \"markdown\"}\n# ### Dependencies & Prerequisites\n#\n# <div class=\"alert alert-success\">\n#     Tensorflow Probability is part of the colab default runtime, <b>so you don't need to install Tensorflow or Tensorflow Probability if you're running this in the colab</b>. \n#     <br>\n#     If you're running this notebook in Jupyter on your own machine (and you have already installed Tensorflow), you can use the following\n#     <br>\n#       <ul>\n#     <li> For the most recent nightly installation: <code>pip3 install -q tfp-nightly</code></li>\n#     <li> For the most recent stable TFP release: <code>pip3 install -q --upgrade tensorflow-probability</code></li>\n#     <li> For the most recent stable GPU-connected version of TFP: <code>pip3 install -q --upgrade tensorflow-probability-gpu</code></li>\n#     <li> For the most recent nightly GPU-connected version of TFP: <code>pip3 install -q tfp-nightly-gpu</code></li>\n#     </ul>\n# Again, if you are running this in a Colab, Tensorflow and TFP are already installed\n# </div>\n# -\n\n# ## 2020-02-07\n#\n# The following code cell contains bizarre comment formatting, like `#@title` ... `{ display-mode: \"form\" }` and `#@markdown`. Is that Colab-specific Markdown?\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"RUEQ5hdvKZLB\"}\n#@title Imports and Global Variables (make sure to run this cell)  { display-mode: \"form\" }\n# 2020-02-07: wait, why am I importing from __future__ if I'm running python 3.6? I'll do it anyway and figure out why later.\nfrom __future__ import absolute_import, division, print_function\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"RUEQ5hdvKZLB\"}\n#@markdown This sets the warning status (default is `ignore`, since this notebook runs correctly)\n# 2020-02-07: you know what? Let's always see warnings.\nwarning_status = \"always\" #@param [\"ignore\", \"always\", \"module\", \"once\", \"default\", \"error\"]\nimport warnings\nwarnings.filterwarnings(warning_status)\nwith warnings.catch_warnings():\n    warnings.filterwarnings(warning_status, category=DeprecationWarning)\n    warnings.filterwarnings(warning_status, category=UserWarning)\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"RUEQ5hdvKZLB\"}\nimport numpy as np\nimport os\n#@markdown This sets the styles of the plotting (default is styled like plots from [FiveThirtyeight.com](https://fivethirtyeight.com/))\nmatplotlib_style = 'fivethirtyeight' #@param ['fivethirtyeight', 'bmh', 'ggplot', 'seaborn', 'default', 'Solarize_Light2', 'classic', 'dark_background', 'seaborn-colorblind', 'seaborn-notebook']\nimport matplotlib.pyplot as plt; plt.style.use(matplotlib_style)\nimport matplotlib.axes as axes\nfrom matplotlib.patches import Ellipse\n# %matplotlib inline\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"RUEQ5hdvKZLB\"}\nimport seaborn as sns; sns.set_context('notebook')\nfrom IPython.core.pylabtools import figsize\n#@markdown This sets the resolution of the plot outputs (`retina` is the highest resolution)\nnotebook_screen_res = 'retina' #@param ['retina', 'png', 'jpeg', 'svg', 'pdf']\n# %config InlineBackend.figure_format = notebook_screen_res\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"RUEQ5hdvKZLB\"}\nimport tensorflow as tf\n## 2020-02-07: According to https://www.tensorflow.org/guide/eager\n## In Tensorflow 2.0, eager execution is enabled by default.\n##\n# tfe = tf.contrib.eager\ntf.__version__\n# -\ntf.executing_eagerly()\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"RUEQ5hdvKZLB\"}\n## 2020-02-07: this cell is made obsolete by TF 2.0. (Maybe I could open some pull requests to modernize this tutorial,\n## but then I'd have to clone it again and not make these ad-hoc comments to myself)\n##\n## Eager Execution\n##@markdown Check the box below if you want to use [Eager Execution](https://www.tensorflow.org/guide/eager)\n##@markdown Eager execution provides An intuitive interface, Easier debugging, and a control flow comparable to Numpy. You can read more about it on the [Google AI Blog](https://ai.googleblog.com/2017/10/eager-execution-imperative-define-by.html)\n# use_tf_eager = False #@param {type:\"boolean\"}\n# # Use try/except so we can easily re-execute the whole notebook.\n# if use_tf_eager:\n#     try:\n#         tf.enable_eager_execution()\n#     except:\n#         pass\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"RUEQ5hdvKZLB\"}\nimport tensorflow_probability as tfp\ntfd = tfp.distributions\ntfb = tfp.bijectors\n\n\n# -\n\n# **2020-02-07:** someday, this Tensorflow boilerplate will make sense to me, but today is not that day.\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"RUEQ5hdvKZLB\"}\ndef evaluate(tensors):\n    \"\"\"Evaluates Tensor or EagerTensor to Numpy `ndarray`s.\n    Args:\n    tensors: Object of `Tensor` or EagerTensor`s; can be `list`, `tuple`,\n      `namedtuple` or combinations thereof.\n \n    Returns:\n      ndarrays: Object with same structure as `tensors` except with `Tensor` or\n        `EagerTensor`s replaced by Numpy `ndarray`s.\n    \"\"\"\n    if tf.executing_eagerly():\n        return tf.contrib.framework.nest.pack_sequence_as(\n            tensors,\n            [t.numpy() if tf.contrib.framework.is_tensor(t) else t\n             for t in tf.contrib.framework.nest.flatten(tensors)])\n    return sess.run(tensors)\n\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"RUEQ5hdvKZLB\"}\n# 2020-02-07: this is strikingly out of place. Why are we manually defining a colormap?\nclass _TFColor(object):\n    \"\"\"Enum of colors used in TF docs.\"\"\"\n    red = '#F15854'\n    blue = '#5DA5DA'\n    orange = '#FAA43A'\n    green = '#60BD68'\n    pink = '#F17CB0'\n    brown = '#B2912F'\n    purple = '#B276B2'\n    yellow = '#DECF3F'\n    gray = '#4D4D4D'\n    def __getitem__(self, i):\n        return [\n            self.red,\n            self.orange,\n            self.green,\n            self.blue,\n            self.pink,\n            self.brown,\n            self.purple,\n            self.yellow,\n            self.gray,\n        ][i % 9]\nTFColor = _TFColor()\n\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"RUEQ5hdvKZLB\"}\ndef session_options(enable_gpu_ram_resizing=True, enable_xla=False):\n    \"\"\"\n    Allowing the notebook to make use of GPUs if they're available.\n    \n    XLA (Accelerated Linear Algebra) is a domain-specific compiler for linear \n    algebra that optimizes TensorFlow computations.\n    \"\"\"\n    config = tf.compat.v1.ConfigProto()\n    config.log_device_placement = True\n    if enable_gpu_ram_resizing:\n        # `allow_growth=True` makes it possible to connect multiple colabs to your\n        # GPU. Otherwise the colab malloc's all GPU ram.\n        config.gpu_options.allow_growth = True\n    if enable_xla:\n        # Enable on XLA. https://www.tensorflow.org/performance/xla/.\n        config.graph_options.optimizer_options.global_jit_level = (\n            tf.OptimizerOptions.ON_1)\n    return config\n\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"RUEQ5hdvKZLB\"}\n# 2020-02-07: in this cell and the one above it, I had to manually change the namespaces \n# from tf. to tf.compat.v1. This does not strike me as elegant. What's the recommended TF 2 way of doing this?\ndef reset_sess(config=None):\n    \"\"\"\n    Convenience function to create the TF graph & session or reset them.\n    \"\"\"\n    if config is None:\n        config = session_options(enable_gpu_ram_resizing=True, enable_xla=False)\n    global sess\n    tf.compat.v1.reset_default_graph()\n    try:\n        sess.close()\n    except:\n        pass\n    sess = tf.compat.v1.InteractiveSession(config=config)\n\nreset_sess()\n\n# + {\"colab_type\": \"text\", \"id\": \"dXqjzSnXRRr3\", \"cell_type\": \"markdown\"}\n# ## The Philosophy of Bayesian Inference\n#\n# >You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, even more difficult, test too! You are starting to believe that there may be no bugs in this code...\n#\n# If you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more confident about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives.\n#\n#\n\n# + {\"colab_type\": \"text\", \"id\": \"YO2eSwZQRRqv\", \"cell_type\": \"markdown\"}\n# ## The Bayesian state of mind\n# Bayesian inference differs from more traditional statistical inference by preserving uncertainty. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving certainty from randomness? To reconcile this, we need to start thinking like Bayesians.\n#\n# The Bayesian world-view interprets probability as measure of believability in an event, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability.\n#\n# For this to be clearer, we consider an alternative interpretation of probability: Frequentist, known as the more classical version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the probability of plane accidents under a frequentist philosophy is interpreted as the long-term frequency of plane accidents. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability.\n#\n# Bayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of belief, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate A will win?\n#\n# Notice in the paragraph above, I assigned the belief (probability) measure to an individual, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different information about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n#\n# * I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is your belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result.\n#\n# * Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug.\n#\n# * A medical patient is exhibiting symptoms *x*, *y* and *z*. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs.\n#\n# This philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be trained to think like a frequentist.\n#\n# To align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the prior probability.\n#\n# John Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A|X)$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the posterior probability so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n#\n#\n# 1. $P(A)$: the coin has a 50 percent chance of being Heads. $P(A|X)$: You look at the coin, observe a Heads has landed, denote this information  $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n#\n# 2. $P(A)$: This big, complex code likely has a bug in it. $P(A|X)$: The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n#\n# 3. $P(A)$: The patient could have any number of diseases. $P(A|X)$: Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n#\n# It's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we re-weighted the prior to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others).\n#\n# By introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes less wrong. This is the alternative side of the prediction coin, where typically we try to be more right.\n#\n#\n#\n#\n#\n\n# + {\"colab_type\": \"text\", \"id\": \"FXUBMaYsRWvl\", \"cell_type\": \"markdown\"}\n# ## Bayesian Inference in Practice\n# If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return probabilities.\n#\n# For example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a YES. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of YES and NO. The function might return:\n#\n# >YES, with probability 0.8; NO, with probability 0.2\n#\n# This is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: \"Often my code has bugs\". This parameter is the prior. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences.\n#\n# ### Incorporating evidence\n# As we acquire more and more instances of evidence, our prior belief is washed out by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n#\n# Denote $N$ as the number of instances of evidence we possess. As we gather an infinite amount of evidence, say as $N→∞,$ our Bayesian results (often) align with frequentist results. Hence for large N, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more unstable: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we preserve the uncertainty that reflects the instability of statistical inference of a small N dataset.\n#\n# One may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[[1]](#scrollTo=nDdph0r1ABCn), before making such a decision:\n#\n# Sample sizes are never large. If $N$, is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$, is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$, is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n#\n#\n\n# + {\"colab_type\": \"text\", \"id\": \"rACyvZBVdqB9\", \"cell_type\": \"markdown\"}\n# ## Are frequentist methods incorrect then?\n# No.\n#\n# Frequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n#\n# ### A note on *Big Data*\n# Paradoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [[2]](#scrollTo=nDdph0r1ABCn)[[3]](#scrollTo=nDdph0r1ABCn). Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n#\n# The much more difficult analytic problems involve medium data and, especially troublesome, really small data. Using a similar argument as Gelman's above, if big data problems are big enough to be readily solved, then we should be more interested in the not-quite-big enough datasets.\n\n# + {\"colab_type\": \"text\", \"id\": \"TTUDkI8peKw6\", \"cell_type\": \"markdown\"}\n# ## Our Bayesian framework\n# We are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a prior belief in event A, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n#\n# Secondly, we observe our evidence. To continue our buggy-code example: if our code passes X tests, we want to update our belief to incorporate this. We call this new belief the posterior probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n#\n# $$ P(A|X) = \\frac{P(X | A) P(A) }{P(X) } $$\n#\n# $$ P(A|X) \\propto{P(X | A) P(A) } $$\n#\n# NOTE: ($\\propto$ is \"proportional to\")\n#\n#\n# The above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A|X)$.\n\n# + {\"colab_type\": \"text\", \"id\": \"DkB3Ou8UjW-F\", \"cell_type\": \"markdown\"}\n#\n# ## Example: Mandatory coin-flip example\n# Every statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it p, but have no prior opinion on what p might be.\n#\n# We begin to flip a coin, and record the observations: either H or T. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data.\n#\n# Below we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips), while also demonstrating some of the best practices when it comes to evaluating tensors and plotting the data. First, the easy part: We define the values in our Tensorflow graph\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"yFd9GboD7hVV\"}\n# Build Graph\nrv_coin_flip_prior = tfp.distributions.Bernoulli(probs=0.5, dtype=tf.int32)\n\nnum_trials = tf.constant([0,1, 2, 3, 4, 5, 8, 15, 50, 500, 1000, 2000])\n\ncoin_flip_data = rv_coin_flip_prior.sample(num_trials[-1])\n\n# prepend a 0 onto tally of heads and tails, for zeroth flip\ncoin_flip_data = tf.pad(coin_flip_data,tf.constant([[1, 0,]]),\"CONSTANT\")\n\n# compute cumulative headcounts from 0 to 2000 flips, and then grab them at each of num_trials intervals\ncumulative_headcounts = tf.gather(tf.cumsum(coin_flip_data), num_trials)\n\nrv_observed_heads = tfp.distributions.Beta(\n    concentration1=tf.cast(1 + cumulative_headcounts, tf.float32),\n    concentration0=tf.cast(1 + num_trials - cumulative_headcounts, tf.float32))\n\nprobs_of_heads = tf.linspace(start=0., stop=1., num=100, name=\"linspace\")\nobserved_probs_heads = tf.transpose(rv_observed_heads.prob(probs_of_heads[:, tf.newaxis]))\n\n# + {\"colab_type\": \"text\", \"id\": \"eVh-ugqN8NRy\", \"cell_type\": \"markdown\"}\n# Next we move onto executing the graph. When it comes to calculations that need to be made frequently and repeatedly, this method of first-defining and then executing graphs provides a handy speed boost. We can actually use a custom `evaluate()` function that allows us to evaluate tensors whether we are operating in TF Graph mode, or whether we have Eager mode active. The function looks like the following:\n#\n# ```python\n#\n# def evaluate(tensors):\n#     \"\"\"Evaluates Tensor or EagerTensor to Numpy `ndarray`s.\n#     Args:\n#     tensors: Object of `Tensor` or EagerTensor`s; can be `list`, `tuple`,\n#       `namedtuple` or combinations thereof.\n#\n#     Returns:\n#       ndarrays: Object with same structure as `tensors` except with `Tensor` or\n#         `EagerTensor`s replaced by Numpy `ndarray`s.\n#     \"\"\"\n#     if tf.executing_eagerly():\n#         return tf.contrib.framework.nest.pack_sequence_as(\n#             tensors,\n#             [t.numpy() if tf.contrib.framework.is_tensor(t) else t\n#              for t in tf.contrib.framework.nest.flatten(tensors)])\n#     return sess.run(tensors)\n#\n# ```\n#\n# To plot the tensors, we need to convert them into numpy variables. One handy way of associating tensors with their corrresponding numpy variables is to append an underscore to the numpy-like arrays. For example, if the input to `evaluate()` is `variable`, then we assign that value to `variable_`. Below we see an example of how we use both `evaluate()`  and this new styling.\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"Ex3djpOu7_-m\"}\n# Execute graph\n[num_trials_,\nprobs_of_heads_,\nobserved_probs_heads_,\ncumulative_headcounts_,\n] = evaluate([\n  num_trials,\n  probs_of_heads,\n  observed_probs_heads,\n  cumulative_headcounts\n])\n\n# + {\"colab_type\": \"text\", \"id\": \"IUAm6LEA8FFW\", \"cell_type\": \"markdown\"}\n# Finally, we move onto plotting our evaluated tensors in matplotlib.\n\n# + {\"colab\": {\"base_uri\": \"https://localhost:8080/\", \"height\": 697}, \"colab_type\": \"code\", \"id\": \"4fdWiFUT6H-A\", \"outputId\": \"a232d7e8-6825-4e41-f363-1f6c07b176e7\"}\n# For the already prepared, I'm using Binomial's conj. prior.\nplt.figure(figsize(16, 9))\nfor i in range(len(num_trials_)):\n    sx = plt.subplot(len(num_trials_)/2, 2, i+1)\n    plt.xlabel(\"$p$, probability of heads\") \\\n    if i in [0, len(num_trials_)-1] else None\n    plt.setp(sx.get_yticklabels(), visible=False)\n    plt.plot(probs_of_heads_, observed_probs_heads_[i], \n             label=\"observe %d tosses,\\n %d heads\" % (num_trials_[i], cumulative_headcounts_[i]))\n    plt.fill_between(probs_of_heads_, 0, observed_probs_heads_[i], \n                     color=TFColor[3], alpha=0.4)\n    plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n    leg = plt.legend()\n    leg.get_frame().set_alpha(0.4)\n    plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\", y=1.02,\n             fontsize=14)\nplt.tight_layout()\n\n# + {\"colab_type\": \"text\", \"id\": \"jTqKXlGRmKuh\", \"cell_type\": \"markdown\"}\n# The posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line).\n#\n# Notice that the plots are not always peaked at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what p is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased away from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n#\n# The next example is a simple demonstration of the mathematics of Bayesian inference.\n\n# + {\"colab_type\": \"text\", \"id\": \"5UKnxit-mevN\", \"cell_type\": \"markdown\"}\n# ## Example: Bug, or just sweet, unintended feature?\n# Let $A$ denote the event that our code has no bugs in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A)=p$.\n#\n# We are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n#\n# What is $P(X|A)$, i.e., the probability that the code passes $X$ tests given there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests.\n#\n# $P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event X occurring even though our code indeed has bugs (denoted $∼A$, spoken not $A$), or event $X$ without bugs $(A)$. $ P(X)$ can be represented as:\n\n# + {\"colab_type\": \"text\", \"id\": \"7rDu4o6DnjT7\", \"cell_type\": \"markdown\"}\n# $$ \\begin{align*}\n# P(A|X) &= \\frac{P(X | A) P(A) }{P(X) } \\\\\n#  P(X) &= P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\n#   &= P(X|A)P(A) + P(X | \\sim A)P(\\sim A) \\\\\n#   &= P(X|A)p + P(X | \\sim A)(1-p) \\end{align*} $$\n#\n\n# + {\"colab_type\": \"text\", \"id\": \"S48e_3wph3I_\", \"cell_type\": \"markdown\"}\n# We have already computed $P(X|A)$ above. On the other hand, $P(X|\\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A)=0.5$. Then:\n#\n# $$ \\begin{align*}\n# P(A | X) &= \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\n# &= \\frac{ 2 p}{1+p} \\end{align*} $$\n#\n# This is the posterior probability. What does it look like as a function of our prior, $p\\in[0,1]$?\n\n# + {\"colab\": {\"base_uri\": \"https://localhost:8080/\", \"height\": 404}, \"colab_type\": \"code\", \"id\": \"MwjluXPenvAy\", \"outputId\": \"fc433206-8324-4d63-fafc-4f49127182eb\"}\n# Defining our range of probabilities\np = tf.linspace(start=0., stop=1., num=50)\n\n# Convert from TF to numpy.\n[p_] = evaluate([p])\n\n# Visualization.\nplt.figure(figsize=(12.5, 6))\nplt.plot(p_, 2*p_/(1+p_), color=TFColor[3], lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=TFColor[3])\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(r\"Prior, $P(A) = p$\")\nplt.ylabel(r\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(r\"Are there bugs in my code?\");\n\n# + {\"colab_type\": \"text\", \"id\": \"dvcD8UWloYxn\", \"cell_type\": \"markdown\"}\n# We can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33.\n#\n# Recall that the prior is a probability: $p$ is the prior probability that there are no bugs, so $1 \\text{-} p$ is the prior probability that there are bugs.\n#\n# Similarly, our posterior is also a probability, with $P(A|X)$ the probability there is no bug given we saw all tests pass, hence $1 \\text{-} P(A|X)$ is the probability there is a bug given all tests passed. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities.\n\n# + {\"colab\": {\"base_uri\": \"https://localhost:8080/\", \"height\": 279}, \"colab_type\": \"code\", \"id\": \"Aot_QO3n1r4o\", \"outputId\": \"6aa056b4-43c4-4dd3-c616-5fa57028db59\"}\n# Defining our priors and posteriors\nprior = tf.constant([0.20, 0.80])\nposterior = tf.constant([1./3, 2./3])\n\n# Convert from TF to numpy.\n[\n    prior_,\n    posterior_,\n] = evaluate([\n    prior,\n    posterior,\n])\n\n\n# Our Simple Visualization\nplt.figure(figsize=(12.5, 4))\ncolours = [TFColor[0], TFColor[3]]\nplt.bar([0, .7], prior_, alpha=0.70, width=0.25,\n        color=colours[0], label=\"prior distribution\",\n        lw=\"3\", edgecolor=colours[0])\nplt.bar([0+0.25, .7+0.25], posterior_, alpha=0.7,\n        width=0.25, color=colours[1],\n        label=r\"posterior distribution\",\n        lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(r\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n\n# + {\"colab_type\": \"text\", \"id\": \"Xl6KbBeoCkiM\", \"cell_type\": \"markdown\"}\n# Notice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n#\n# This was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with probability distributions. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n# + {\"colab_type\": \"text\", \"id\": \"2zNt6157C0Cr\", \"cell_type\": \"markdown\"}\n# ## Probability Distributions\n# Let's quickly recall what a probability distribution is: Let $Z$ be some random variable. Then associated with $Z$ is a probability distribution function that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter.\n#\n# We can divide random variables into three classifications:\n#\n# *  $Z$ is discrete: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n#\n# * $Z$ is continuous: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n#\n# * $Z$ is mixed: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories.\n#\n#\n#\n\n# + {\"colab_type\": \"text\", \"id\": \"xG03a_sgDRlc\", \"cell_type\": \"markdown\"}\n# ### Discrete Case\n#\n# If $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n#  \n# $$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n#\n#\n# $\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n#\n# Unlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n#\n#\n# If a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n#  \n# $$Z \\sim \\text{Poi}(\\lambda) $$\n#  \n# One useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n#\n# $$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n#\n#\n# We will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n# + {\"colab\": {\"base_uri\": \"https://localhost:8080/\", \"height\": 511}, \"colab_type\": \"code\", \"id\": \"7x8Y_YtNqoPY\", \"outputId\": \"34957d57-c33c-4327-d037-486406bad447\"}\n# Build graph.\nx = tf.range (start=0., limit=16.)\nlambdas = tf.constant([1.5, 4.25])\n\npoi_pmf = tfd.Poisson(\n  rate=lambdas[:, tf.newaxis]).prob(x)\n\n# Execute graph\n[\n  x_,\n  lambdas_,\n  poi_pmf_,\n] = evaluate([\n  x,\n  lambdas,\n  poi_pmf,\n])\n\nplt.figure(figsize=(12.5, 8))\n\n# Display results in two different histograms, for easier comparison\ncolours = [TFColor[0], TFColor[3]]\nfor i in [0,1]:\n  ax = plt.subplot(2,1,i+1)\n  ax.set_autoscaley_on(False)\n  plt.title(\"Probability mass function of a Poisson random variable\");\n\n  plt.bar(x_,\n          poi_pmf_[i],\n          color=colours[i],\n          label=r\"$\\lambda = %.1f$\" % lambdas_[i], alpha=0.60,\n          edgecolor=colours[i], lw=\"3\")\n  plt.xticks(x_ + 0.4, x_)\n  plt.ylim([0, .5])\n  plt.legend()\n  plt.ylabel(r\"probability of $k$\")\n  plt.xlabel(r\"$k$\")\n\n# + {\"colab_type\": \"text\", \"id\": \"ipS19FlBEmqK\", \"cell_type\": \"markdown\"}\n# ### Continuous Case\n#\n# Instead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n#\n# $$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n#  \n# Like a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n#\n# When a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n#\n# $$Z \\sim \\text{Exp}(\\lambda)$$\n#  \n# Given a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n#\n# $$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n# + {\"colab\": {\"base_uri\": \"https://localhost:8080/\", \"height\": 296}, \"colab_type\": \"code\", \"id\": \"o1aeMH4VE9xs\", \"outputId\": \"34756f32-6058-4cf2-e8a1-1a5da2cb85a6\"}\n# Defining our Data and assumptions (use tf.linspace for continuous)\na = tf.range(start=0., limit=4., delta=0.04)\na = a[..., tf.newaxis]\nlambdas = tf.constant([0.5, 1.])\n\n# Now we use TFP to compute probabilities in a vectorized manner.\nexpo_pdf = tfd.Exponential(rate=lambdas).prob(a)\n\n# Convert from TF to numpy\n[\n    a_,\n    lambdas_,\n    expo_pdf_,\n] = evaluate([\n    a,\n    lambdas,\n    expo_pdf,\n])\n\n# Visualizing our results\nplt.figure(figsize=(12.5, 4))\nfor i in range(lambdas_.size):\n    plt.plot(a_.T[0], expo_pdf_.T[[i]][0],\n             lw=3, color=TFColor[i], label=r\"$\\lambda = %.1f$\" % lambdas_[i])\n    plt.fill_between(a_.T[0], expo_pdf_.T[[i]][0],\n                         color=TFColor[i], alpha=.33)\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(r\"Probability density function of an Exponential random variable; differing $\\lambda$\");\n\n\n# + {\"colab_type\": \"text\", \"id\": \"_1fhqQhAFLkk\", \"cell_type\": \"markdown\"}\n#  \n# ## But what is $\\lambda \\;$?\n#\n# **This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n#\n# Bayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n#  \n# This might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n#\n\n# + {\"colab_type\": \"text\", \"id\": \"JrRddMMfHHKJ\", \"cell_type\": \"markdown\"}\n#  \n# #### Example: Inferring behaviour from text-message data\n#  \n# Let's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n#\n# >  You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n#\n#\n\n# + {\"colab\": {\"base_uri\": \"https://localhost:8080/\", \"height\": 294}, \"colab_type\": \"code\", \"id\": \"cOBOnwa2IIaB\", \"outputId\": \"43123229-1b53-4ba0-9527-ee633a683b13\"}\n# Defining our Data and assumptions\ncount_data = tf.constant([\n    13,  24,   8,  24,   7,  35,  14,  11,  15,  11,  22,  22,  11,  57,  \n    11,  19,  29,   6,  19,  12,  22,  12,  18,  72,  32,   9,   7,  13,  \n    19,  23,  27,  20,   6,  17,  13,  10,  14,   6,  16,  15,   7,   2,  \n    15,  15,  19,  70,  49,   7,  53,  22,  21,  31,  19,  11,  18,  20,  \n    12,  35,  17,  23,  17,   4,   2,  31,  30,  13,  27,   0,  39,  37,   \n    5,  14,  13,  22,\n], dtype=tf.float32)\nn_count_data = tf.shape(count_data)\ndays = tf.range(n_count_data[0])\n\n# Convert from TF to numpy.\n\n[\n    count_data_, \n    n_count_data_, \n    days_,\n] = evaluate([\n    count_data, \n    n_count_data,\n    days,\n])\n\n# Visualizing the Results\n    \nplt.figure(figsize=(12.5, 4))\nplt.bar(days_, count_data_, color=\"#5DA5DA\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data_[0]);\n\n\n# + {\"colab_type\": \"text\", \"id\": \"i-PRmpvsIZKq\", \"cell_type\": \"markdown\"}\n#\n# Before we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n#  \n# How can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n#  \n# $$ C_i \\sim \\text{Poisson}(\\lambda)  $$\n#  \n# We are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n#  \n# How can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n#  \n# $$\\lambda = \n# \\begin{cases} \\lambda_1  & \\text{if } t \\lt \\tau \\cr\n# \\lambda_2 & \\text{if } t \\ge \\tau\n# \\end{cases}\n# $$\n#\n# If, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n#\n# We are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n# $$\n# \\begin{align}\n# &\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\n# &\\lambda_2 \\sim \\text{Exp}( \\alpha )\n# \\end{align}\n# $$\n# $\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice.  A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n#\n# $$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n#  \n# An alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n#  \n# What about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n# $$\n# \\begin{align}\n# & \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\n# & \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n# \\end{align}\n# $$\n# So after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n#\n# We next turn to [TensorFlow Probability](https://tensorflow.org/probability), a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created.\n\n# + {\"colab_type\": \"text\", \"id\": \"mCz2BozPcYNy\", \"cell_type\": \"markdown\"}\n# ## Introducing our first hammer: TensorFlow Probability\n#\n# TensorFlow Probability (TFP) is a Python library for programming Bayesian analysis. It is intended for data scientists, statisticians, machine learning practitioners, and scientists. Since it is built on the TensorFlow (TF) stack, it brings the runtime benefits of TF to Bayesian analysis. These include write-once run-many (ability to run your development model in production) and speedups via state-of-the-art hardware (GPUs and TPUs). \n#\n# Since TFP is relatively new, the TFP community is actively developing documentation, \n# especially docs and examples that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why TFP is so cool.\n#\n# We will model the problem above using TFP. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. \n#\n# B. Cronin [[4]](#scrollTo=nDdph0r1ABCn) has a very motivating description of probabilistic programming:\n#\n# >   Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n#\n# Because of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n#  \n# TFP code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables.\n\n# + {\"colab_type\": \"text\", \"id\": \"gYVjgZQ3hOw-\", \"cell_type\": \"markdown\"}\n# ## Specify the joint log-density\n#\n# We'll assume the data is a consequence of the following generative model:\n#\n# $$\\begin{align*}\n# \\lambda_{1}^{(0)} &\\sim \\text{Exponential}(\\text{rate}=\\alpha) \\\\\n# \\lambda_{2}^{(0)} &\\sim \\text{Exponential}(\\text{rate}=\\alpha) \\\\\n# \\tau &\\sim \\text{Uniform}[\\text{low}=0,\\text{high}=1) \\\\\n# \\text{for }  i &= 1\\ldots N: \\\\\n# \\lambda_i &= \\begin{cases} \\lambda_{1}^{(0)}, & \\tau > i/N \\\\ \\lambda_{2}^{(0)}, & \\text{otherwise}\\end{cases}\\\\\n#  X_i &\\sim \\text{Poisson}(\\text{rate}=\\lambda_i)\n# \\end{align*}$$\n#\n# Happily, this model can be easily implemented using TF and TFP's distributions:\n#\n#\n# This code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. The [gather](https://https://www.tensorflow.org/api_docs/python/tf/gather) function assigns `lambda_1` or `lambda_2` as the value of `lambda_`, depending on what side of `tau` we are on. The values of `lambda_` up until `tau` are `lambda_1` and the values afterwards are `lambda_2`.\n#\n# Note that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n#\n# TFP performs probabilistic inference by evaluating the model parameters using a joint_log_prob function, which we'll describe more in Chapter 2.\n#\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"rYc_bbho-QzH\"}\ndef joint_log_prob(count_data, lambda_1, lambda_2, tau):\n    tfd = tfp.distributions\n \n    alpha = np.array(1. / count_data.mean(), np.float32)\n    rv_lambda_1 = tfd.Exponential(rate=alpha)\n    rv_lambda_2 = tfd.Exponential(rate=alpha)\n \n    rv_tau = tfd.Uniform()\n \n    lambda_ = tf.gather(\n         [lambda_1, lambda_2],\n         indices=tf.to_int32(tau * count_data.size <= np.arange(count_data.size)))\n    rv_observation = tfd.Poisson(rate=lambda_)\n \n    return (\n         rv_lambda_1.log_prob(lambda_1)\n         + rv_lambda_2.log_prob(lambda_2)\n         + rv_tau.log_prob(tau)\n         + tf.reduce_sum(rv_observation.log_prob(count_data))\n    )\n\n\n# + {\"colab_type\": \"text\", \"id\": \"t7Vvrj68jsr7\", \"cell_type\": \"markdown\"}\n# Notice that the implementation is arguably very close to being a 1:1 translation of the mathematical model. The main difference is merely that once we've specified the probabilistic model, we return the sum of the log_probs.\n\n# + {\"colab_type\": \"text\", \"id\": \"KnyDyY8Tjyiy\", \"cell_type\": \"markdown\"}\n# ## Specify the posterior sampler\n\n# + {\"colab_type\": \"text\", \"id\": \"CGreTr4ljwuF\", \"cell_type\": \"markdown\"}\n# The code below will be explained in Chapter 3, but we show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which we also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"YBCXrK9gj8Gx\"}\n# Set the chain's start state.\ninitial_chain_state = [\n    tf.cast(tf.reduce_mean(count_data), tf.float32) * tf.ones([], dtype=tf.float32, name=\"init_lambda1\"),\n    tf.cast(tf.reduce_mean(count_data), tf.float32) * tf.ones([], dtype=tf.float32, name=\"init_lambda2\", tf.float32),\n    0.5 * tf.ones([], dtype=tf.float32, name=\"init_tau\"),\n]\n\n\n# Since HMC operates over unconstrained space, we need to transform the\n# samples so they live in real-space.\nunconstraining_bijectors = [\n    tfp.bijectors.Exp(),       # Maps a positive real to R.\n    tfp.bijectors.Exp(),       # Maps a positive real to R.\n    tfp.bijectors.Sigmoid(),   # Maps [0,1] to R.  \n]\n\n\ndef joint_log_prob(count_data, lambda_1, lambda_2, tau):\n    tfd = tfp.distributions\n \n    alpha = (1. / tf.reduce_mean(count_data))\n    rv_lambda_1 = tfd.Exponential(rate=alpha)\n    rv_lambda_2 = tfd.Exponential(rate=alpha)\n \n    rv_tau = tfd.Uniform()\n \n\n    lambda_ = tf.gather(\n         [lambda_1, lambda_2],\n         indices=tf.to_int32(tau * tf.cast(tf.size(count_data), tf.float32) <= tf.cast(tf.range(tf.size(count_data)), tf.float32)))\n    rv_observation = tfd.Poisson(rate=lambda_)\n \n    return (\n         rv_lambda_1.log_prob(lambda_1)\n         + rv_lambda_2.log_prob(lambda_2)\n         + rv_tau.log_prob(tau)\n         + tf.reduce_sum(rv_observation.log_prob(count_data))\n    )\n\n\n# Define a closure over our joint_log_prob.\ndef unnormalized_log_posterior(lambda1, lambda2, tau):\n    return joint_log_prob(count_data, lambda1, lambda2, tau)\n\n\n# Initialize the step_size. (It will be automatically adapted.)\nwith tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\n    step_size = tf.get_variable(\n        name='step_size',\n        initializer=tf.constant(0.05, dtype=tf.float32),\n        trainable=False,\n        use_resource=True\n    )\n\n# Sample from the chain.\n[\n    lambda_1_samples,\n    lambda_2_samples,\n    posterior_tau,\n], kernel_results = tfp.mcmc.sample_chain(\n    num_results=100000,\n    num_burnin_steps=10000,\n    current_state=initial_chain_state,\n    kernel=tfp.mcmc.TransformedTransitionKernel(\n        inner_kernel=tfp.mcmc.HamiltonianMonteCarlo(\n            target_log_prob_fn=unnormalized_log_posterior,\n            num_leapfrog_steps=2,\n            step_size=step_size,\n            step_size_update_fn=tfp.mcmc.make_simple_step_size_update_policy(),\n            state_gradients_are_stopped=True),\n        bijector=unconstraining_bijectors))\n\ntau_samples = tf.floor(posterior_tau * tf.cast(tf.size(count_data)), tf.float32)\n\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tf.shape(tau_samples)[0]\nexpected_texts_per_day = tf.zeros(n_count_data)\n\n\n# Initialize any created variables.\ninit_g = tf.global_variables_initializer()\ninit_l = tf.local_variables_initializer()\n\n\n# + {\"colab_type\": \"text\", \"id\": \"N1mb2NDUkJLU\", \"cell_type\": \"markdown\"}\n# ## Executing the TF graph to sample from the posterior\n\n# + {\"colab\": {\"base_uri\": \"https://localhost:8080/\", \"height\": 53}, \"colab_type\": \"code\", \"id\": \"NpNv545ZkLjb\", \"outputId\": \"e0fdbba7-3a66-44a5-910c-d2caa3d84a4f\"}\nevaluate(init_g)\nevaluate(init_l)\n[\n    lambda_1_samples_,\n    lambda_2_samples_,\n    tau_samples_,\n    kernel_results_,\n    N_,\n    expected_texts_per_day_,\n] = evaluate([\n    lambda_1_samples,\n    lambda_2_samples,\n    tau_samples,\n    kernel_results,\n    N,\n    expected_texts_per_day,\n])\n\n    \nprint(\"acceptance rate: {}\".format(\n    kernel_results_.inner_results.is_accepted.mean()))\nprint(\"final step size: {}\".format(\n    kernel_results_.inner_results.extra.step_size_assign[-100:].mean()))\n\n\n\n# + {\"colab_type\": \"text\", \"id\": \"vIxEqx9qkhWr\", \"cell_type\": \"markdown\"}\n# ## Plot the Results\n\n# + {\"colab\": {\"base_uri\": \"https://localhost:8080/\", \"height\": 896}, \"colab_type\": \"code\", \"id\": \"viLRm6DEkRPM\", \"outputId\": \"bab21304-d1da-4f91-ed27-66ef070202f5\"}\nplt.figure(figsize=(12.5, 15))\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples_, histtype='stepfilled', bins=30, alpha=0.85,\n         label=r\"posterior of $\\lambda_1$\", color=TFColor[0], density=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(r\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples_, histtype='stepfilled', bins=30, alpha=0.85,\n         label=r\"posterior of $\\lambda_2$\", color=TFColor[6], density=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(r\"$\\lambda_2$ value\")\n\nplt.subplot(313)\nw = 1.0 / tau_samples_.shape[0] * np.ones_like(tau_samples_)\nplt.hist(tau_samples_, bins=n_count_data_[0], alpha=1,\n         label=r\"posterior of $\\tau$\",\n         color=TFColor[2], weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data_[0]))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data_)-20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(r\"probability\");\n\n# + {\"colab_type\": \"text\", \"id\": \"FfiTXgF80sDA\", \"cell_type\": \"markdown\"}\n# ## Interpretation\n#\n# Recall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n#\n# What other observations can you make? If you look at the original data again, do these results seem reasonable? \n#\n# Notice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n#  \n# Our analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n#\n# ### Why would I want samples from the posterior, anyways?\n#\n# We will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n#\n# We'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n#  \n# In the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n#\n\n# + {\"colab\": {\"base_uri\": \"https://localhost:8080/\", \"height\": 566}, \"colab_type\": \"code\", \"id\": \"DgNkjkmO1h4I\", \"outputId\": \"195a4269-7f76-4bc3-ec1b-a2f9c6a09ceb\"}\nplt.figure(figsize=(12.5, 9))\n\nfor day in range(0, n_count_data_[0]):\n    # ix is a bool index of all tau samples corresponding to\n    # the switchpoint occurring prior to value of 'day'\n    ix = day < tau_samples_\n    # Each posterior sample corresponds to a value for tau.\n    # for each day, that value of tau indicates whether we're \"before\"\n    # (in the lambda1 \"regime\") or\n    #  \"after\" (in the lambda2 \"regime\") the switchpoint.\n    # by taking the posterior sample of lambda1/2 accordingly, we can average\n    # over all samples to get an expected value for lambda on that day.\n    # As explained, the \"message count\" random variable is Poisson distributed,\n    # and therefore lambda (the poisson parameter) is the expected value of\n    # \"message count\".\n    expected_texts_per_day_[day] = (lambda_1_samples_[ix].sum()\n                                   + lambda_2_samples_[~ix].sum()) / N_\n\n\nplt.plot(range(n_count_data_[0]), expected_texts_per_day_, lw=4, color=\"#E24A33\",\n         label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data_[0])\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data_)), count_data_, color=\"#5DA5DA\", alpha=0.65,\n        label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n\n# + {\"colab_type\": \"text\", \"id\": \"cgCrDy8M3IZT\", \"cell_type\": \"markdown\"}\n# Our analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n#\n#\n# ## Exercises\n#  \n# 1.   Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n#\n#\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"ddpQzca9ACJF\"}\n#type your code here.\n\n# + {\"colab_type\": \"text\", \"id\": \"p4krLq5J_356\", \"cell_type\": \"markdown\"}\n# 2.   What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"qWoCGbmEAEvb\"}\n#type your code here.\n\n# + {\"colab_type\": \"text\", \"id\": \"vGHVkSlp_9zf\", \"cell_type\": \"markdown\"}\n# 3. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45? That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the TFP part. Just consider all instances where `tau_samples < 45`.)\n\n# + {\"colab\": {}, \"colab_type\": \"code\", \"id\": \"worLRhcVAFeK\"}\n#type your code here.\n\n# + {\"colab_type\": \"text\", \"id\": \"nDdph0r1ABCn\", \"cell_type\": \"markdown\"}\n# ## References\n#\n# [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg)\n#  \n# [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n#\n# [3] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n#\n# [4] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. <https://plus.google.com/u/0/107971134877020469960/posts/KpeRdJKR6Z1>.\n\n# + {\"colab\": {\"base_uri\": \"https://localhost:8080/\", \"height\": 331}, \"colab_type\": \"code\", \"id\": \"FY5Ftmqh3IC6\", \"outputId\": \"d4cac394-c473-4de5-86d9-b58a08c33fd6\"}\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open(\"../styles/custom.css\", \"r\").read()\n    return HTML(styles)\ncss_styling()\n\n", "meta": {"hexsha": "901f98e337113a064baf28476b292287c126025e", "size": 66768, "ext": "py", "lang": "Python", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_TFP.py", "max_stars_repo_name": "pjleimbigler/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "0d7bd5d6e447fb64d91d93b1098421c717435229", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_TFP.py", "max_issues_repo_name": "pjleimbigler/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "0d7bd5d6e447fb64d91d93b1098421c717435229", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_TFP.py", "max_forks_repo_name": "pjleimbigler/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "0d7bd5d6e447fb64d91d93b1098421c717435229", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 62.1097674419, "max_line_length": 904, "alphanum_fraction": 0.7243739516, "include": true, "reason": "import numpy", "num_tokens": 17632, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.411110869232168, "lm_q2_score": 0.22541661063147309, "lm_q1q2_score": 0.09267121873607406}}
{"text": "from __future__ import division, absolute_import, print_function\nfrom past.builtins import xrange\n\nimport numpy as np\nimport os\nimport sys\nimport esutil\nimport time\n\nfrom .fgcmUtilities import _pickle_method\nfrom .fgcmUtilities import objFlagDict\nfrom .fgcmUtilities import retrievalFlagDict\n\nimport types\ntry:\n    import copy_reg as copyreg\nexcept ImportError:\n    import copyreg\n\nimport multiprocessing\nfrom multiprocessing import Pool\n\nfrom .sharedNumpyMemManager import SharedNumpyMemManager as snmm\n\ncopyreg.pickle(types.MethodType, _pickle_method)\n\n## FIXME: derivatives should not be zero when hitting the boundary (check)\n\nclass FgcmChisq(object):\n    \"\"\"\n    Class which computes the chi-squared for the fit.\n\n    parameters\n    ----------\n    fgcmConfig: FgcmConfig\n       Config object\n    fgcmPars: FgcmParameters\n       Parameter object\n    fgcmStars: FgcmStars\n       Stars object\n    fgcmLUT: FgcmLUT\n       LUT object\n\n    Config variables\n    ----------------\n    nCore: int\n       Number of cores to run in multiprocessing\n    nStarPerRun: int\n       Number of stars per run.  More can use more memory.\n    noChromaticCorrections: bool\n       If set to True, then no chromatic corrections are applied.  (bad idea).\n    \"\"\"\n\n    def __init__(self,fgcmConfig,fgcmPars,fgcmStars,fgcmLUT):\n\n        self.fgcmLog = fgcmConfig.fgcmLog\n\n        #self.fgcmLog.log('INFO','Initializing FgcmChisq')\n        self.fgcmLog.info('Initializing FgcmChisq')\n\n        # does this need to be shm'd?\n        self.fgcmPars = fgcmPars\n\n        # this is shm'd\n        self.fgcmLUT = fgcmLUT\n\n        # also shm'd\n        self.fgcmStars = fgcmStars\n\n        # need to configure\n        self.nCore = fgcmConfig.nCore\n        self.ccdStartIndex = fgcmConfig.ccdStartIndex\n        self.nStarPerRun = fgcmConfig.nStarPerRun\n        self.noChromaticCorrections = fgcmConfig.noChromaticCorrections\n\n        # these are the standard *band* I10s\n        self.I10StdBand = fgcmConfig.I10StdBand\n\n        self.illegalValue = fgcmConfig.illegalValue\n\n        if (fgcmConfig.useSedLUT and self.fgcmLUT.hasSedLUT):\n            self.useSedLUT = True\n        else:\n            self.useSedLUT = False\n\n        self.resetFitChisqList()\n\n        # this is the default number of parameters\n        self.nActualFitPars = self.fgcmPars.nFitPars\n        #self.fgcmLog.log('INFO','Default: fit %d parameters.' % (self.nActualFitPars))\n        self.fgcmLog.info('Default: fit %d parameters.' % (self.nActualFitPars))\n\n        self.clearMatchCache()\n\n\n    def resetFitChisqList(self):\n        \"\"\"\n        Reset the recorded list of chi-squared values.\n        \"\"\"\n\n        self.fitChisqs = []\n\n    def clearMatchCache(self):\n        \"\"\"\n        Clear the pre-match cache.  Note that this isn't working right.\n        \"\"\"\n        self.matchesCached = False\n        self.goodObs = None\n        self.goodStarsSub = None\n\n    def __call__(self,fitParams,fitterUnits=False,computeDerivatives=False,computeSEDSlopes=False,useMatchCache=False,debug=False,allExposures=False,includeReserve=False,fgcmGray=None):\n        \"\"\"\n        Compute the chi-squared for a given set of parameters.\n\n        parameters\n        ----------\n        fitParams: numpy array of floats\n           Array with the numerical values of the parameters (properly formatted).\n        fitterUnits: bool, default=False\n           Are the units of fitParams normalized for the minimizer?\n        computeDerivatives: bool, default=False\n           Compute fit derivatives?\n        computeSEDSlopes: bool, default=False\n           Compute SED slopes from magnitudes?\n        useMatchCache: bool, default=False\n           Cache observation matches.  Do not use!\n        debug: bool, default=False\n           Debug mode with no multiprocessing\n        allExposures: bool, default=False\n           Compute using all exposures, including flagged/non-photometric\n        includeReserve: bool, default=False\n           Compute using all objects, including those put in reserve.\n        fgcmGray: FgcmGray, default=None\n           CCD Gray information for computing with \"ccd crunch\"\n        \"\"\"\n\n        # computeDerivatives: do we want to compute the derivatives?\n        # computeSEDSlope: compute SED Slope and recompute mean mags?\n        # fitterUnits: units of th fitter or \"true\" units?\n\n        self.computeDerivatives = computeDerivatives\n        self.computeSEDSlopes = computeSEDSlopes\n        self.fitterUnits = fitterUnits\n        self.allExposures = allExposures\n        self.useMatchCache = useMatchCache\n        self.includeReserve = includeReserve\n        self.fgcmGray = fgcmGray    # may be None\n\n        self.fgcmLog.debug('FgcmChisq: computeDerivatives = %d' %\n                         (int(computeDerivatives)))\n        self.fgcmLog.debug('FgcmChisq: computeSEDSlopes = %d' %\n                         (int(computeSEDSlopes)))\n        self.fgcmLog.debug('FgcmChisq: fitterUnits = %d' %\n                         (int(fitterUnits)))\n        self.fgcmLog.debug('FgcmChisq: allExposures = %d' %\n                         (int(allExposures)))\n        self.fgcmLog.debug('FgcmChisq: includeReserve = %d' %\n                         (int(includeReserve)))\n\n        startTime = time.time()\n\n        if (self.allExposures and (self.computeDerivatives or\n                                   self.computeSEDSlopes)):\n            raise ValueError(\"Cannot set allExposures and computeDerivatives or computeSEDSlopes\")\n        self.fgcmPars.reloadParArray(fitParams,fitterUnits=self.fitterUnits)\n        self.fgcmPars.parsToExposures()\n\n\n        # and reset numbers if necessary\n        if (not self.allExposures):\n            snmm.getArray(self.fgcmStars.objMagStdMeanHandle)[:] = 99.0\n            snmm.getArray(self.fgcmStars.objMagStdMeanNoChromHandle)[:] = 99.0\n            snmm.getArray(self.fgcmStars.objMagStdMeanErrHandle)[:] = 99.0\n\n        # do we want to include reserve stars?\n        if (self.includeReserve):\n            # this mask will filter everything but RESERVED\n            resMask = 255 & ~objFlagDict['RESERVED']\n            goodStars,=np.where((snmm.getArray(self.fgcmStars.objFlagHandle) & resMask) == 0)\n        else:\n            goodStars,=np.where(snmm.getArray(self.fgcmStars.objFlagHandle) == 0)\n\n        self.fgcmLog.info('Found %d good stars for chisq' % (goodStars.size))\n\n        if (goodStars.size == 0):\n            raise ValueError(\"No good stars to fit!\")\n\n        # do global pre-matching before giving to workers, because\n        #  it is faster this way\n\n        obsObjIDIndex = snmm.getArray(self.fgcmStars.obsObjIDIndexHandle)\n        obsExpIndex = snmm.getArray(self.fgcmStars.obsExpIndexHandle)\n        obsFlag = snmm.getArray(self.fgcmStars.obsFlagHandle)\n\n        if (self.useMatchCache and self.matchesCached) :\n            # we have already done the matching\n            self.fgcmLog.info('Retrieving cached matches')\n            goodObs = self.goodObs\n            goodStarsSub = self.goodStarsSub\n        else:\n            # we need to do matching\n            preStartTime=time.time()\n            self.fgcmLog.info('Pre-matching stars and observations...')\n            goodStarsSub,goodObs = esutil.numpy_util.match(goodStars,\n                                                           obsObjIDIndex,\n                                                           presorted=True)\n\n            if (goodStarsSub[0] != 0.0):\n                raise ValueError(\"Very strange that the goodStarsSub first element is non-zero.\")\n\n            if (not self.allExposures):\n                # cut out all bad exposures and bad observations\n                gd,=np.where((self.fgcmPars.expFlag[obsExpIndex[goodObs]] == 0) &\n                             (obsFlag[goodObs] == 0))\n            else:\n                # just cut out bad observations\n                gd,=np.where(obsFlag[goodObs] == 0)\n\n            # crop out both goodObs and goodStarsSub\n            goodObs=goodObs[gd]\n            goodStarsSub=goodStarsSub[gd]\n\n            self.fgcmLog.info('Pre-matching done in %.1f sec.' %\n                             (time.time() - preStartTime))\n\n            if (self.useMatchCache) :\n                self.fgcmLog.info('Caching matches for next iteration')\n                self.matchesCached = True\n                self.goodObs = goodObs\n                self.goodStarsSub = goodStarsSub\n\n        self.nSums = 2  # chisq, nobs\n        if (self.computeDerivatives):\n            # we have one for each of the derivatives\n            # and a duplicate set to track which parameters were \"touched\"\n            self.nSums += 2*self.fgcmPars.nFitPars\n\n        self.debug = debug\n        if (self.debug):\n            # debug mode: single core\n            self.totalHandleDict = {}\n            self.totalHandleDict[0] = snmm.createArray(self.nSums,dtype='f8')\n\n            self._worker((goodStars,goodObs))\n\n            partialSums = snmm.getArray(self.totalHandleDict[0])[:]\n        else:\n            # regular multi-core\n\n\n            # make a dummy process to discover starting child number\n            proc = multiprocessing.Process()\n            workerIndex = proc._identity[0]+1\n            proc = None\n\n            self.totalHandleDict = {}\n            for thisCore in xrange(self.nCore):\n                self.totalHandleDict[workerIndex + thisCore] = (\n                    snmm.createArray(self.nSums,dtype='f8'))\n\n            # split goodStars into a list of arrays of roughly equal size\n\n            prepStartTime = time.time()\n            nSections = goodStars.size // self.nStarPerRun + 1\n            goodStarsList = np.array_split(goodStars,nSections)\n\n\n            # is there a better way of getting all the first elements from the list?\n            #  note that we need to skip the first which should be zero (checked above)\n            #  see also fgcmBrightObs.py\n            # splitValues is the first of the goodStars in each list\n            splitValues = np.zeros(nSections-1,dtype='i4')\n            for i in xrange(1,nSections):\n                splitValues[i-1] = goodStarsList[i][0]\n\n            # get the indices from the goodStarsSub matched list (matched to goodStars)\n            splitIndices = np.searchsorted(goodStars[goodStarsSub], splitValues)\n\n            # and split along the indices\n            goodObsList = np.split(goodObs,splitIndices)\n\n            workerList = list(zip(goodStarsList,goodObsList))\n\n            # reverse sort so the longest running go first\n            workerList.sort(key=lambda elt:elt[1].size, reverse=True)\n\n            self.fgcmLog.info('Using %d sections (%.1f seconds)' %\n                             (nSections,time.time()-prepStartTime))\n\n            self.fgcmLog.info('Running chisq on %d cores' % (self.nCore))\n\n            # make a pool\n            pool = Pool(processes=self.nCore)\n            pool.map(self._worker,workerList,chunksize=1)\n            pool.close()\n            pool.join()\n\n            # sum up the partial sums from the different jobs\n            partialSums = np.zeros(self.nSums,dtype='f8')\n            for thisCore in xrange(self.nCore):\n                partialSums[:] += snmm.getArray(\n                    self.totalHandleDict[workerIndex + thisCore])[:]\n\n\n        if (not self.allExposures):\n            # we get the number of fit parameters by counting which of the parameters\n            #  have been touched by the data (number of touches is irrelevant)\n\n            if (self.computeDerivatives):\n                nonZero, = np.where(partialSums[self.fgcmPars.nFitPars:\n                                                    2*self.fgcmPars.nFitPars] > 0)\n                self.nActualFitPars = nonZero.size\n                self.fgcmLog.info('Actually fit %d parameters.' % (self.nActualFitPars))\n\n            fitDOF = partialSums[-1] - float(self.nActualFitPars)\n\n            if (fitDOF <= 0):\n                raise ValueError(\"Number of parameters fitted is more than number of constraints! (%d > %d)\" % (self.fgcmPars.nFitPars,partialSums[-1]))\n\n            fitChisq = partialSums[-2] / fitDOF\n            if (self.computeDerivatives):\n                dChisqdP = partialSums[0:self.fgcmPars.nFitPars] / fitDOF\n\n            # want to append this...\n            self.fitChisqs.append(fitChisq)\n\n            self.fgcmLog.info('Chisq/dof = %.2f (%d iterations)' %\n                             (fitChisq, len(self.fitChisqs)))\n\n        else:\n            try:\n                fitChisq = self.fitChisqs[-1]\n            except:\n                fitChisq = 0.0\n\n        # free shared arrays\n        for key in self.totalHandleDict.keys():\n            snmm.freeArray(self.totalHandleDict[key])\n\n        self.fgcmLog.info('Chisq computation took %.2f seconds.' %\n                         (time.time() - startTime))\n\n        self.fgcmStars.magStdComputed = True\n        if (self.allExposures):\n            self.fgcmStars.allMagStdComputed = True\n\n        if (self.computeDerivatives):\n            return fitChisq, dChisqdP\n        else:\n            return fitChisq\n\n    def _worker(self,goodStarsAndObs):\n        \"\"\"\n        Multiprocessing worker for FgcmChisq.  Not to be called on its own.\n\n        parameters\n        ----------\n        goodStarsAndObs: tuple[2]\n           (goodStars, goodObs)\n        \"\"\"\n\n        # NOTE: No logging is allowed in the _worker method\n\n        workerStartTime = time.time()\n\n        goodStars = goodStarsAndObs[0]\n        goodObs = goodStarsAndObs[1]\n\n        if self.debug:\n            thisCore = 0\n        else:\n            thisCore = multiprocessing.current_process()._identity[0]\n\n        objMagStdMean = snmm.getArray(self.fgcmStars.objMagStdMeanHandle)\n        objMagStdMeanNoChrom = snmm.getArray(self.fgcmStars.objMagStdMeanNoChromHandle)\n        objMagStdMeanErr = snmm.getArray(self.fgcmStars.objMagStdMeanErrHandle)\n        objSEDSlope = snmm.getArray(self.fgcmStars.objSEDSlopeHandle)\n        objNGoodObs = snmm.getArray(self.fgcmStars.objNGoodObsHandle)\n\n        obsObjIDIndex = snmm.getArray(self.fgcmStars.obsObjIDIndexHandle)\n\n        obsExpIndex = snmm.getArray(self.fgcmStars.obsExpIndexHandle)\n        obsBandIndex = snmm.getArray(self.fgcmStars.obsBandIndexHandle)\n        obsLUTFilterIndex = snmm.getArray(self.fgcmStars.obsLUTFilterIndexHandle)\n        obsCCDIndex = snmm.getArray(self.fgcmStars.obsCCDHandle) - self.ccdStartIndex\n        obsFlag = snmm.getArray(self.fgcmStars.obsFlagHandle)\n        obsSecZenith = snmm.getArray(self.fgcmStars.obsSecZenithHandle)\n        obsMagADU = snmm.getArray(self.fgcmStars.obsMagADUHandle)\n        # obsMagADUErr = snmm.getArray(self.fgcmStars.obsMagADUErrHandle)\n        obsMagADUModelErr = snmm.getArray(self.fgcmStars.obsMagADUModelErrHandle)\n        obsMagStd = snmm.getArray(self.fgcmStars.obsMagStdHandle)\n\n        # and fgcmGray stuff (if desired)\n        if (self.fgcmGray is not None):\n            ccdGray = snmm.getArray(self.fgcmGray.ccdGrayHandle)\n            # this is ccdGray[expIndex, ccdIndex]\n            # and we only apply when > self.illegalValue\n            # same sign as FGCM_DUST (QESys)\n\n        # and the arrays for locking access\n        objMagStdMeanLock = snmm.getArrayBase(self.fgcmStars.objMagStdMeanHandle).get_lock()\n        obsMagStdLock = snmm.getArrayBase(self.fgcmStars.obsMagStdHandle).get_lock()\n\n\n        # cut these down now, faster later\n        obsObjIDIndexGO = obsObjIDIndex[goodObs]\n        obsBandIndexGO = obsBandIndex[goodObs]\n        obsLUTFilterIndexGO = obsLUTFilterIndex[goodObs]\n        obsExpIndexGO = obsExpIndex[goodObs]\n        obsSecZenithGO = obsSecZenith[goodObs]\n        obsCCDIndexGO = obsCCDIndex[goodObs]\n\n        # which observations are used in the fit?\n        _,obsFitUseGO = esutil.numpy_util.match(self.fgcmPars.fitBandIndex,\n                                                obsBandIndexGO)\n\n        # now refer to obsBandIndex[goodObs]\n        # add GO to index names that are cut to goodObs\n        # add GOF to index names that are cut to goodObs[obsFitUseGO]\n\n        lutIndicesGO = self.fgcmLUT.getIndices(obsLUTFilterIndexGO,\n                                               self.fgcmPars.expPWV[obsExpIndexGO],\n                                               self.fgcmPars.expO3[obsExpIndexGO],\n                                               #np.log(self.fgcmPars.expTau[obsExpIndexGO]),\n                                               self.fgcmPars.expLnTau[obsExpIndexGO],\n                                               self.fgcmPars.expAlpha[obsExpIndexGO],\n                                               obsSecZenithGO,\n                                               obsCCDIndexGO,\n                                               self.fgcmPars.expPmb[obsExpIndexGO])\n        I0GO = self.fgcmLUT.computeI0(self.fgcmPars.expPWV[obsExpIndexGO],\n                                      self.fgcmPars.expO3[obsExpIndexGO],\n                                      #np.log(self.fgcmPars.expTau[obsExpIndexGO]),\n                                      self.fgcmPars.expLnTau[obsExpIndexGO],\n                                      self.fgcmPars.expAlpha[obsExpIndexGO],\n                                      obsSecZenithGO,\n                                      self.fgcmPars.expPmb[obsExpIndexGO],\n                                      lutIndicesGO)\n        I10GO = self.fgcmLUT.computeI1(self.fgcmPars.expPWV[obsExpIndexGO],\n                                       self.fgcmPars.expO3[obsExpIndexGO],\n                                       #np.log(self.fgcmPars.expTau[obsExpIndexGO]),\n                                       self.fgcmPars.expLnTau[obsExpIndexGO],\n                                       self.fgcmPars.expAlpha[obsExpIndexGO],\n                                       obsSecZenithGO,\n                                       self.fgcmPars.expPmb[obsExpIndexGO],\n                                       lutIndicesGO) / I0GO\n\n\n        qeSysGO = self.fgcmPars.expQESys[obsExpIndexGO]\n\n        obsMagGO = obsMagADU[goodObs] + 2.5*np.log10(I0GO) + qeSysGO\n\n        if (self.fgcmGray is not None):\n            # We want to apply the \"CCD Gray Crunch\"\n            # make sure we aren't adding something crazy, but this shouldn't happen\n            # because we're filtering good observations (I hope!)\n            ok,=np.where(ccdGray[obsExpIndexGO, obsCCDIndexGO] > self.illegalValue)\n            obsMagGO[ok] += ccdGray[obsExpIndexGO[ok], obsCCDIndexGO[ok]]\n\n        # Compute the sub-selected error-squared, using model error when available\n        obsMagErr2GO = obsMagADUModelErr[goodObs]**2.\n\n        if (self.computeSEDSlopes):\n            # first, compute mean mags (code same as below.  FIXME: consolidate, but how?)\n\n            # make temp vars.  With memory overhead\n\n            wtSum = np.zeros_like(objMagStdMean,dtype='f8')\n            objMagStdMeanTemp = np.zeros_like(objMagStdMean)\n\n            np.add.at(wtSum,\n                      (obsObjIDIndexGO,obsBandIndexGO),\n                      1./obsMagErr2GO)\n            np.add.at(objMagStdMeanTemp,\n                  (obsObjIDIndexGO,obsBandIndexGO),\n                  obsMagGO/obsMagErr2GO)\n\n            # these are good object/bands that were observed\n            gd=np.where(wtSum > 0.0)\n\n            # and acquire lock to save the values\n            objMagStdMeanLock.acquire()\n\n            objMagStdMean[gd] = objMagStdMeanTemp[gd] / wtSum[gd]\n            objMagStdMeanErr[gd] = np.sqrt(1./wtSum[gd])\n\n            # and release the lock.\n            objMagStdMeanLock.release()\n\n            if (self.useSedLUT):\n                self.fgcmStars.computeObjectSEDSlopesLUT(goodStars,self.fgcmLUT)\n            else:\n                self.fgcmStars.computeObjectSEDSlopes(goodStars)\n\n        # compute linearized chromatic correction\n        deltaStdGO = 2.5 * np.log10((1.0 +\n                                   objSEDSlope[obsObjIDIndexGO,\n                                               obsBandIndexGO] * I10GO) /\n                                  (1.0 + objSEDSlope[obsObjIDIndexGO,\n                                                     obsBandIndexGO] *\n                                   self.I10StdBand[obsBandIndexGO]))\n\n        if self.noChromaticCorrections:\n            # NOT RECOMMENDED\n            deltaStdGO *= 0.0\n\n        # we can only do this for calibration stars.\n        #  must reference the full array to save\n\n        # acquire lock when we write to and retrieve from full array\n        obsMagStdLock.acquire()\n\n        obsMagStd[goodObs] = obsMagGO + deltaStdGO\n        # this is cut here\n        obsMagStdGO = obsMagStd[goodObs]\n\n        # we now have a local cut copy, so release\n        obsMagStdLock.release()\n\n        # kick out if we're just computing magstd for all exposures\n        if (self.allExposures) :\n            # kick out\n            return None\n\n        # compute mean mags\n\n        # we make temporary variables.  These are less than ideal because they\n        #  take up the full memory footprint.  MAYBE look at making a smaller\n        #  array just for the stars under consideration, but this would make the\n        #  indexing in the np.add.at() more difficult\n\n        wtSum = np.zeros_like(objMagStdMean,dtype='f8')\n        objMagStdMeanTemp = np.zeros_like(objMagStdMean)\n        objMagStdMeanNoChromTemp = np.zeros_like(objMagStdMeanNoChrom)\n\n        np.add.at(wtSum,\n                  (obsObjIDIndexGO,obsBandIndexGO),\n                  1./obsMagErr2GO)\n\n        np.add.at(objMagStdMeanTemp,\n                  (obsObjIDIndexGO,obsBandIndexGO),\n                  obsMagStdGO/obsMagErr2GO)\n\n        # And the same thing with the non-chromatic corrected values\n        np.add.at(objMagStdMeanNoChromTemp,\n                  (obsObjIDIndexGO,obsBandIndexGO),\n                  obsMagGO/obsMagErr2GO)\n\n        # which objects/bands have observations?\n        gd=np.where(wtSum > 0.0)\n\n        # and acquire lock to save the values\n        objMagStdMeanLock.acquire()\n\n        objMagStdMean[gd] = objMagStdMeanTemp[gd] / wtSum[gd]\n        objMagStdMeanNoChrom[gd] = objMagStdMeanNoChromTemp[gd] / wtSum[gd]\n        objMagStdMeanErr[gd] = np.sqrt(1./wtSum[gd])\n\n        # also make local copies for Good Observations\n        objMagStdMeanGO = objMagStdMean[obsObjIDIndexGO,obsBandIndexGO]\n        objMagStdMeanErr2GO = objMagStdMeanErr[obsObjIDIndexGO,obsBandIndexGO]**2.\n\n        # and release the lock.\n        objMagStdMeanLock.release()\n\n        # compute delta-mags\n\n        deltaMagGO = (obsMagStdGO - objMagStdMeanGO)\n\n        # Note that this is the model error when we have it\n        obsWeightGO = 1. / obsMagErr2GO\n\n        deltaMagWeightedGOF = deltaMagGO[obsFitUseGO] * obsWeightGO[obsFitUseGO]\n\n        partialChisq = np.sum(deltaMagGO[obsFitUseGO]**2. * obsWeightGO[obsFitUseGO])\n\n        partialArray = np.zeros(self.nSums,dtype='f8')\n        partialArray[-2] = partialChisq\n        partialArray[-1] = obsFitUseGO.size\n\n        if (self.computeDerivatives):\n            unitDict=self.fgcmPars.getUnitDict(fitterUnits=self.fitterUnits)\n\n            # this is going to be ugly.  wow, how many indices and sub-indices?\n            #  or does it simplify since we need all the obs on a night?\n            #  we shall see!  And speed up!\n\n            (dLdPWVGO,dLdO3GO,dLdTauGO,dLdAlphaGO) = (\n                self.fgcmLUT.computeLogDerivatives(lutIndicesGO,\n                                                   I0GO))\n\n            if (self.fgcmLUT.hasI1Derivatives):\n                (dLdPWVI1GO,dLdO3I1GO,dLdTauI1GO,dLdAlphaI1GO) = (\n                    self.fgcmLUT.computeLogDerivativesI1(lutIndicesGO,\n                                                         I0GO,\n                                                         I10GO,\n                                                         objSEDSlope[obsObjIDIndexGO,\n                                                                     obsBandIndexGO]))\n                dLdPWVGO += dLdPWVI1GO\n                dLdO3GO += dLdO3I1GO\n                dLdTauGO += dLdTauI1GO\n                dLdAlphaGO += dLdAlphaI1GO\n\n\n            # we have objMagStdMeanErr[objIndex,:] = \\Sum_{i\"} 1/\\sigma^2_{i\"j}\n            #   note that this is summed over all observations of an object in a band\n            #   so that this is already done\n\n            # we need magdLdp = \\Sum_{i'} (1/\\sigma^2_{i'j}) dL(i',j|p)\n            #   note that this is summed over all observations in a filter that\n            #   touch a given parameter\n\n            # set up arrays\n            magdLdPWVIntercept = np.zeros((self.fgcmPars.nCampaignNights,\n                                           self.fgcmPars.nFitBands))\n            magdLdPWVPerSlope = np.zeros_like(magdLdPWVIntercept)\n            magdLdPWVOffset = np.zeros_like(magdLdPWVIntercept)\n            magdLdTauIntercept = np.zeros_like(magdLdPWVIntercept)\n            magdLdTauPerSlope = np.zeros_like(magdLdPWVIntercept)\n            magdLdTauOffset = np.zeros_like(magdLdPWVIntercept)\n            magdLdAlpha = np.zeros_like(magdLdPWVIntercept)\n            magdLdO3 = np.zeros_like(magdLdPWVIntercept)\n\n            magdLdPWVScale = np.zeros(self.fgcmPars.nFitBands,dtype='f4')\n            magdLdTauScale = np.zeros_like(magdLdPWVScale)\n\n            magdLdPWVRetrievedScale = np.zeros(self.fgcmPars.nFitBands,dtype='f4')\n            magdLdPWVRetrievedOffset = np.zeros_like(magdLdPWVRetrievedScale)\n            magdLdPWVRetrievedNightlyOffset = np.zeros_like(magdLdPWVIntercept)\n\n            magdLdWashIntercept = np.zeros((self.fgcmPars.nWashIntervals,\n                                            self.fgcmPars.nFitBands))\n            magdLdWashSlope = np.zeros_like(magdLdWashIntercept)\n\n            # note below that objMagStdMeanErr2GO is the the square of the error,\n            #  and already cut to [obsObjIDIndexGO,obsBandIndexGO]\n\n            ##########\n            ## O3\n            ##########\n\n            expNightIndexGOF = self.fgcmPars.expNightIndex[obsExpIndexGO[obsFitUseGO]]\n            uNightIndex = np.unique(expNightIndexGOF)\n\n            np.add.at(magdLdO3,\n                      (expNightIndexGOF,obsBandIndexGO[obsFitUseGO]),\n                      dLdO3GO[obsFitUseGO] / obsMagErr2GO[obsFitUseGO])\n            np.multiply.at(magdLdO3,\n                           (expNightIndexGOF,obsBandIndexGO[obsFitUseGO]),\n                           objMagStdMeanErr2GO[obsFitUseGO])\n            np.add.at(partialArray[self.fgcmPars.parO3Loc:\n                                       (self.fgcmPars.parO3Loc+\n                                        self.fgcmPars.nCampaignNights)],\n                      expNightIndexGOF,\n                      deltaMagWeightedGOF * (\n                    (dLdO3GO[obsFitUseGO] -\n                     magdLdO3[expNightIndexGOF,obsBandIndexGO[obsFitUseGO]])))\n\n            partialArray[self.fgcmPars.parO3Loc +\n                         uNightIndex] *= (2.0 / unitDict['o3Unit'])\n            partialArray[self.fgcmPars.nFitPars +\n                         self.fgcmPars.parO3Loc +\n                         uNightIndex] += 1\n\n            ###########\n            ## Alpha\n            ###########\n\n            np.add.at(magdLdAlpha,\n                      (expNightIndexGOF,obsBandIndexGO[obsFitUseGO]),\n                      dLdAlphaGO[obsFitUseGO] / obsMagErr2GO[obsFitUseGO])\n            np.multiply.at(magdLdAlpha,\n                           (expNightIndexGOF,obsBandIndexGO[obsFitUseGO]),\n                           objMagStdMeanErr2GO[obsFitUseGO])\n            np.add.at(partialArray[self.fgcmPars.parAlphaLoc:\n                                       (self.fgcmPars.parAlphaLoc+\n                                        self.fgcmPars.nCampaignNights)],\n                      expNightIndexGOF,\n                      deltaMagWeightedGOF * (\n                    (dLdAlphaGO[obsFitUseGO] -\n                     magdLdAlpha[expNightIndexGOF,obsBandIndexGO[obsFitUseGO]])))\n\n            partialArray[self.fgcmPars.parAlphaLoc +\n                         uNightIndex] *= (2.0 / unitDict['alphaUnit'])\n            partialArray[self.fgcmPars.nFitPars +\n                         self.fgcmPars.parAlphaLoc +\n                         uNightIndex] += 1\n\n\n            ###########\n            ## PWV External\n            ###########\n\n            if (self.fgcmPars.hasExternalPWV and not self.fgcmPars.useRetrievedPWV):\n                hasExtGOF,=np.where(self.fgcmPars.externalPWVFlag[obsExpIndexGO[obsFitUseGO]])\n                uNightIndexHasExt = np.unique(expNightIndexGOF[hasExtGOF])\n\n                # PWV Nightly Offset\n                np.add.at(magdLdPWVOffset,\n                          (expNightIndexGOF[hasExtGOF],\n                           obsBandIndexGO[obsFitUseGO[hasExtGOF]]),\n                          dLdPWVGO[obsFitUseGO[hasExtGOF]] /\n                          obsMagErr2GO[obsFitUseGO[hasExtGOF]])\n                np.multiply.at(magdLdPWVOffset,\n                               (expNightIndexGOF[hasExtGOF],\n                                obsBandIndexGO[obsFitUseGO[hasExtGOF]]),\n                               objMagStdMeanErr2GO[obsFitUseGO[hasExtGOF]])\n                np.add.at(partialArray[self.fgcmPars.parExternalPWVOffsetLoc:\n                                           (self.fgcmPars.parExternalPWVOffsetLoc+\n                                            self.fgcmPars.nCampaignNights)],\n                          expNightIndexGOF[hasExtGOF],\n                          deltaMagWeightedGOF[hasExtGOF] * (\n                        (dLdPWVGO[obsFitUseGO[hasExtGOF]] -\n                         magdLdPWVOffset[expNightIndexGOF[hasExtGOF],\n                                         obsBandIndexGO[obsFitUseGO[hasExtGOF]]])))\n                partialArray[self.fgcmPars.parExternalPWVOffsetLoc +\n                             uNightIndexHasExt] *= (2.0 / unitDict['pwvUnit'])\n                partialArray[self.fgcmPars.nFitPars +\n                             self.fgcmPars.parExternalPWVOffsetLoc +\n                             uNightIndexHasExt] += 1\n\n\n                # PWV Global Scale\n                np.add.at(magdLdPWVScale,\n                          obsBandIndexGO[obsFitUseGO[hasExtGOF]],\n                          self.fgcmPars.expPWV[obsExpIndexGO[obsFitUseGO[hasExtGOF]]] *\n                          dLdPWVGO[obsFitUseGO[hasExtGOF]] /\n                          obsMagErr2GO[obsFitUseGO[hasExtGOF]])\n                np.multiply.at(magdLdPWVScale,\n                               obsBandIndexGO[obsFitUseGO[hasExtGOF]],\n                               objMagStdMeanErr2GO[obsFitUseGO[hasExtGOF]])\n                partialArray[self.fgcmPars.parExternalPWVScaleLoc] = 2.0 * (\n                    np.sum(deltaMagWeightedGOF[hasExtGOF] * (\n                            self.fgcmPars.expPWV[obsExpIndexGO[obsFitUseGO[hasExtGOF]]] *\n                            dLdPWVGO[obsFitUseGO[hasExtGOF]] -\n                            magdLdPWVScale[obsBandIndexGO[obsFitUseGO[hasExtGOF]]])) /\n                    unitDict['pwvGlobalUnit'])\n                partialArray[self.fgcmPars.nFitPars +\n                             self.fgcmPars.parExternalPWVScaleLoc] += 1\n\n            ################\n            ## PWV Retrieved\n            ################\n\n            if (self.fgcmPars.useRetrievedPWV):\n                hasRetrievedPWVGOF, = np.where((self.fgcmPars.compRetrievedPWVFlag[obsExpIndexGO[obsFitUseGO]] &\n                                                retrievalFlagDict['EXPOSURE_RETRIEVED']) > 0)\n\n                if hasRetrievedPWVGOF.size > 0:\n                    # note this might be zero-size on first run\n\n                    # PWV Retrieved Global Scale\n                    np.add.at(magdLdPWVRetrievedScale,\n                              obsBandIndexGO[obsFitUseGO[hasRetrievedPWVGOF]],\n                              self.fgcmPars.expPWV[obsExpIndexGO[obsFitUseGO[hasRetrievedPWVGOF]]] *\n                              dLdPWVGO[obsFitUseGO[hasRetrievedPWVGOF]] /\n                              obsMagErr2GO[obsFitUseGO[hasRetrievedPWVGOF]])\n                    np.multiply.at(magdLdPWVRetrievedScale,\n                                   obsBandIndexGO[obsFitUseGO[hasRetrievedPWVGOF]],\n                                   objMagStdMeanErr2GO[obsFitUseGO[hasRetrievedPWVGOF]])\n                    partialArray[self.fgcmPars.parRetrievedPWVScaleLoc] = 2.0 * (\n                        np.sum(deltaMagWeightedGOF[hasRetrievedPWVGOF] * (\n                                self.fgcmPars.expPWV[obsExpIndexGO[obsFitUseGO[hasRetrievedPWVGOF]]] *\n                                dLdPWVGO[obsFitUseGO[hasRetrievedPWVGOF]] -\n                                magdLdPWVRetrievedScale[obsBandIndexGO[obsFitUseGO[hasRetrievedPWVGOF]]])) /\n                        unitDict['pwvGlobalUnit'])\n                    partialArray[self.fgcmPars.nFitPars +\n                                 self.fgcmPars.parRetrievedPWVScaleLoc] += 1\n\n                    if self.fgcmPars.useNightlyRetrievedPWV:\n                        # PWV Retrieved Nightly Offset\n\n                        uNightIndexHasRetrievedPWV = np.unique(expNightIndexGOF[hasRetrievedPWVGOF])\n\n                        np.add.at(magdLdPWVRetrievedNightlyOffset,\n                                  (expNightIndexGOF[hasRetrievedPWVGOF],\n                                   obsBandIndexGO[obsFitUseGO[hasRetrievedPWVGOF]]),\n                                  dLdPWVGO[obsFitUseGO[hasRetrievedPWVGOF]] /\n                                  obsMagErr2GO[obsFitUseGO[hasRetrievedPWVGOF]])\n                        np.multiply.at(magdLdPWVRetrievedNightlyOffset,\n                                       (expNightIndexGOF[hasRetrievedPWVGOF],\n                                        obsBandIndexGO[obsFitUseGO[hasRetrievedPWVGOF]]),\n                                       objMagStdMeanErr2GO[obsFitUseGO[hasRetrievedPWVGOF]])\n                        np.add.at(partialArray[self.fgcmPars.parRetrievedPWVNightlyOffsetLoc:\n                                                   (self.fgcmPars.parRetrievedPWVNightlyOffsetLoc+\n                                                    self.fgcmPars.nCampaignNights)],\n                                  expNightIndexGOF[hasRetrievedPWVGOF],\n                                  deltaMagWeightedGOF[hasRetrievedPWVGOF] * (\n                                (dLdPWVGO[obsFitUseGO[hasRetrievedPWVGOF]] -\n                                 magdLdPWVRetrievedNightlyOffset[expNightIndexGOF[hasRetrievedPWVGOF],\n                                                                 obsBandIndexGO[obsFitUseGO[hasRetrievedPWVGOF]]])))\n                        partialArray[self.fgcmPars.parRetrievedPWVNightlyOffsetLoc +\n                                     uNightIndexHasRetrievedPWV] *= (2.0 / unitDict['pwvUnit'])\n                        partialArray[self.fgcmPars.nFitPars +\n                                     self.fgcmPars.parRetrievedPWVNightlyOffsetLoc +\n                                     uNightIndexHasRetrievedPWV] += 1\n\n                    else:\n                        # PWV Retrieved Global Offset\n                        np.add.at(magdLdPWVRetrievedOffset,\n                                  obsBandIndexGO[obsFitUseGO[hasRetrievedPWVGOF]],\n                                  dLdPWVGO[obsFitUseGO[hasRetrievedPWVGOF]] /\n                                  obsMagErr2GO[obsFitUseGO[hasRetrievedPWVGOF]])\n                        np.multiply.at(magdLdPWVRetrievedOffset,\n                                       obsBandIndexGO[obsFitUseGO[hasRetrievedPWVGOF]],\n                                       objMagStdMeanErr2GO[obsFitUseGO[hasRetrievedPWVGOF]])\n                        partialArray[self.fgcmPars.parRetrievedPWVOffsetLoc] = 2.0 * (\n                            np.sum(deltaMagWeightedGOF[hasRetrievedPWVGOF] * (\n                                    dLdPWVGO[obsFitUseGO[hasRetrievedPWVGOF]] -\n                                    magdLdPWVRetrievedOffset[obsBandIndexGO[obsFitUseGO[hasRetrievedPWVGOF]]])) /\n                            unitDict['pwvGlobalUnit'])\n                        partialArray[self.fgcmPars.nFitPars +\n                                     self.fgcmPars.parRetrievedPWVOffsetLoc] += 1\n\n            else:\n                ###########\n                ## PWV No External\n                ###########\n\n                noExtGOF, = np.where(~self.fgcmPars.externalPWVFlag[obsExpIndexGO[obsFitUseGO]])\n                uNightIndexNoExt = np.unique(expNightIndexGOF[noExtGOF])\n\n                # PWV Nightly Intercept\n\n                np.add.at(magdLdPWVIntercept,\n                          (expNightIndexGOF[noExtGOF],\n                           obsBandIndexGO[obsFitUseGO[noExtGOF]]),\n                          dLdPWVGO[obsFitUseGO[noExtGOF]] /\n                          obsMagErr2GO[obsFitUseGO[noExtGOF]])\n                np.multiply.at(magdLdPWVIntercept,\n                               (expNightIndexGOF[noExtGOF],\n                                obsBandIndexGO[obsFitUseGO[noExtGOF]]),\n                               objMagStdMeanErr2GO[obsFitUseGO[noExtGOF]])\n                np.add.at(partialArray[self.fgcmPars.parPWVInterceptLoc:\n                                           (self.fgcmPars.parPWVInterceptLoc+\n                                            self.fgcmPars.nCampaignNights)],\n                          expNightIndexGOF[noExtGOF],\n                          deltaMagWeightedGOF[noExtGOF] * (\n                        (dLdPWVGO[obsFitUseGO[noExtGOF]] -\n                         magdLdPWVOffset[expNightIndexGOF[noExtGOF],\n                                         obsBandIndexGO[obsFitUseGO[noExtGOF]]])))\n\n                partialArray[self.fgcmPars.parPWVInterceptLoc +\n                             uNightIndexNoExt] *= (2.0 / unitDict['pwvUnit'])\n                partialArray[self.fgcmPars.nFitPars +\n                             self.fgcmPars.parPWVInterceptLoc +\n                             uNightIndexNoExt] += 1\n\n                # PWV Nightly Percent Slope\n                np.add.at(magdLdPWVPerSlope,\n                          (expNightIndexGOF[noExtGOF],\n                           obsBandIndexGO[obsFitUseGO[noExtGOF]]),\n                          self.fgcmPars.expDeltaUT[obsExpIndexGO[obsFitUseGO[noExtGOF]]] *\n                          self.fgcmPars.expPWV[obsExpIndexGO[obsFitUseGO[noExtGOF]]] *\n                          dLdPWVGO[obsFitUseGO[noExtGOF]] /\n                          obsMagErr2GO[obsFitUseGO[noExtGOF]])\n                np.multiply.at(magdLdPWVPerSlope,\n                               (expNightIndexGOF[noExtGOF],\n                                obsBandIndexGO[obsFitUseGO[noExtGOF]]),\n                               objMagStdMeanErr2GO[obsFitUseGO[noExtGOF]])\n                np.add.at(partialArray[self.fgcmPars.parPWVPerSlopeLoc:\n                                           (self.fgcmPars.parPWVPerSlopeLoc+\n                                            self.fgcmPars.nCampaignNights)],\n                          expNightIndexGOF[noExtGOF],\n                          deltaMagWeightedGOF[noExtGOF] * (\n                        (self.fgcmPars.expDeltaUT[obsExpIndexGO[obsFitUseGO[noExtGOF]]] *\n                         self.fgcmPars.expPWV[obsExpIndexGO[obsFitUseGO[noExtGOF]]] *\n                         dLdPWVGO[obsFitUseGO[noExtGOF]] -\n                         magdLdPWVPerSlope[expNightIndexGOF[noExtGOF],\n                                           obsBandIndexGO[obsFitUseGO[noExtGOF]]])))\n\n                partialArray[self.fgcmPars.parPWVPerSlopeLoc +\n                             uNightIndex] *= (2.0 / unitDict['pwvPerSlopeUnit'])\n                partialArray[self.fgcmPars.nFitPars +\n                             self.fgcmPars.parPWVPerSlopeLoc] += 1\n\n            #############\n            ## Tau External\n            #############\n\n            if (self.fgcmPars.hasExternalTau):\n                hasExtGOF,=np.where(self.fgcmPars.externalTauFlag[obsExpIndexGO[obsFitUseGO]])\n                uNightIndexHasExt = np.unique(expNightIndexGOF[hasExtGOF])\n\n                # Tau Nightly Offset\n                np.add.at(magdLdTauOffset,\n                          (expNightIndexGOF[hasExtGOF],\n                           obsBandIndexGO[obsFitUseGO[hasExtGOF]]),\n                          dLdTauGO[obsFitUseGO[hasExtGOF]] /\n                          obsMagErr2GO[obsFitUseGO[hasExtGOF]])\n                np.multiply.at(magdLdTauOffset,\n                               (expNightIndexGOF[hasExtGOF],\n                                obsBandIndexGO[obsFitUseGO[hasExtGOF]]),\n                               objMagStdMeanErr2GO[obsFitUseGO[hasExtGOF]])\n                np.add.at(partialArray[self.fgcmPars.parExternalTauOffsetLoc:\n                                           (self.fgcmPars.parExternalTauOffsetLoc+\n                                            self.fgcmPars.nCampaignNights)],\n                          expNightIndexGOF[hasExtGOF],\n                          deltaMagWeightedGOF[hasExtGOF] * (\n                        (dLdTauGO[obsFitUseGO[hasExtGOF]] -\n                         magdLdTauOffset[expNightIndexGOF[hasExtGOF],\n                                         obsBandIndexGO[obsFitUseGO[hasExtGOF]]])))\n\n                partialArray[self.fgcmPars.parExternalTauOffsetLoc +\n                             uNightIndexHasExt] *= (2.0 / unitDict['tauUnit'])\n                partialArray[self.fgcmPars.nFitPars +\n                             self.fgcmPars.parExternalTauOffsetLoc +\n                             uNightIndexHasExt] += 1\n\n                # Tau Global Scale\n                ## MAYBE: is this correct with the logs?\n                np.add.at(magdLdTauScale,\n                          obsBandIndexGO[obsFitUseGO[hasExtGOF]],\n                          self.fgcmPars.expTau[obsExpIndexGO[obsFitUseGO[hasExtGOF]]] *\n                          dLdTauGO[obsFitUseGO[hasExtGOF]] /\n                          obsMagErr2GO[obsFitUseGO[hasExtGOF]])\n                np.multiply.at(magdLdTauScale,\n                               obsBandIndexGO[obsFitUseGO[hasExtGOF]],\n                               objMagStdMeanErr2GO[obsFitUseGO[hasExtGOF]])\n                partialArray[self.fgcmPars.parExternalTauScaleLoc] = 2.0 * (\n                    np.sum(deltaMagWeightedGOF[hasExtGOF] * (\n                            self.fgcmPars.expTau[obsExpIndexGO[obsFitUseGO[hasExtGOF]]] *\n                            dLdTauGO[obsFitUseGO[hasExtGOF]] -\n                            magdLdPWVScale[obsBandIndexGO[obsFitUseGO[hasExtGOF]]])) /\n                    unitDict['tauUnit'])\n                partialArray[self.fgcmPars.nFitPars +\n                             self.fgcmPars.parExternalTauScaleLoc] += 1\n\n            ###########\n            ## Tau No External\n            ###########\n\n            noExtGOF, = np.where(~self.fgcmPars.externalTauFlag[obsExpIndexGO[obsFitUseGO]])\n            uNightIndexNoExt = np.unique(expNightIndexGOF[noExtGOF])\n\n            # lnTau Nightly Intercept\n            np.add.at(magdLdTauIntercept,\n                      (expNightIndexGOF[noExtGOF],\n                       obsBandIndexGO[obsFitUseGO[noExtGOF]]),\n                      dLdTauGO[obsFitUseGO[noExtGOF]] /\n                      obsMagErr2GO[obsFitUseGO[noExtGOF]])\n            np.multiply.at(magdLdTauIntercept,\n                           (expNightIndexGOF[noExtGOF],\n                            obsBandIndexGO[obsFitUseGO[noExtGOF]]),\n                           objMagStdMeanErr2GO[obsFitUseGO[noExtGOF]])\n            np.add.at(partialArray[self.fgcmPars.parLnTauInterceptLoc:\n                                       (self.fgcmPars.parLnTauInterceptLoc+\n                                        self.fgcmPars.nCampaignNights)],\n                      expNightIndexGOF[noExtGOF],\n                      deltaMagWeightedGOF[noExtGOF] * (\n                    (dLdTauGO[obsFitUseGO[noExtGOF]] -\n                     magdLdTauOffset[expNightIndexGOF[noExtGOF],\n                                     obsBandIndexGO[obsFitUseGO[noExtGOF]]])))\n\n            partialArray[self.fgcmPars.parLnTauInterceptLoc +\n                         uNightIndexNoExt] *= (2.0 / unitDict['lnTauUnit'])\n            partialArray[self.fgcmPars.nFitPars +\n                         self.fgcmPars.parLnTauInterceptLoc +\n                         uNightIndexNoExt] += 1\n\n            # lnTau nightly slope\n            np.add.at(magdLdTauPerSlope,\n                      (expNightIndexGOF[noExtGOF],\n                       obsBandIndexGO[obsFitUseGO[noExtGOF]]),\n                      self.fgcmPars.expDeltaUT[obsExpIndexGO[obsFitUseGO[noExtGOF]]] *\n                      #self.fgcmPars.expTau[obsExpIndexGO[obsFitUseGO[noExtGOF]]] *\n                      dLdTauGO[obsFitUseGO[noExtGOF]] /\n                      obsMagErr2GO[obsFitUseGO[noExtGOF]])\n            np.multiply.at(magdLdTauPerSlope,\n                           (expNightIndexGOF[noExtGOF],\n                            obsBandIndexGO[obsFitUseGO[noExtGOF]]),\n                           objMagStdMeanErr2GO[obsFitUseGO[noExtGOF]])\n            np.add.at(partialArray[self.fgcmPars.parLnTauSlopeLoc:\n                                       (self.fgcmPars.parLnTauSlopeLoc+\n                                        self.fgcmPars.nCampaignNights)],\n                      expNightIndexGOF[noExtGOF],\n                      deltaMagWeightedGOF[noExtGOF] * (\n                    (self.fgcmPars.expDeltaUT[obsExpIndexGO[obsFitUseGO[noExtGOF]]] *\n                     #self.fgcmPars.expTau[obsExpIndexGO[obsFitUseGO[noExtGOF]]] *\n                     dLdTauGO[obsFitUseGO[noExtGOF]] -\n                     magdLdTauPerSlope[expNightIndexGOF[noExtGOF],\n                                       obsBandIndexGO[obsFitUseGO[noExtGOF]]])))\n\n            partialArray[self.fgcmPars.parLnTauSlopeLoc +\n                         uNightIndexNoExt] *= (2.0 / unitDict['lnTauSlopeUnit'])\n            partialArray[self.fgcmPars.nFitPars +\n                         self.fgcmPars.parLnTauSlopeLoc +\n                         uNightIndexNoExt] += 1\n\n\n            #############\n            ## Washes (QE Sys)\n            #############\n\n            expWashIndexGOF = self.fgcmPars.expWashIndex[obsExpIndexGO[obsFitUseGO]]\n            uWashIndex = np.unique(expWashIndexGOF)\n\n            # Wash Intercept\n            np.add.at(magdLdWashIntercept,\n                      (expWashIndexGOF,obsBandIndexGO[obsFitUseGO]),\n                      1./obsMagErr2GO[obsFitUseGO])\n            np.multiply.at(magdLdWashIntercept,\n                           (expWashIndexGOF,obsBandIndexGO[obsFitUseGO]),\n                           objMagStdMeanErr2GO[obsFitUseGO])\n            np.add.at(partialArray[self.fgcmPars.parQESysInterceptLoc:\n                                       (self.fgcmPars.parQESysInterceptLoc +\n                                        self.fgcmPars.nWashIntervals)],\n                      expWashIndexGOF,\n                      deltaMagWeightedGOF * (\n                    (1.0 - magdLdWashIntercept[expWashIndexGOF,\n                                               obsBandIndexGO[obsFitUseGO]])))\n\n            partialArray[self.fgcmPars.parQESysInterceptLoc +\n                         uWashIndex] *= (2.0 / unitDict['qeSysUnit'])\n            partialArray[self.fgcmPars.nFitPars +\n                         self.fgcmPars.parQESysInterceptLoc +\n                         uWashIndex] += 1\n\n            # Wash Slope\n            np.add.at(magdLdWashSlope,\n                      (expWashIndexGOF,obsBandIndexGO[obsFitUseGO]),\n                      (self.fgcmPars.expMJD[obsExpIndexGO[obsFitUseGO]] -\n                       self.fgcmPars.washMJDs[expWashIndexGOF]) /\n                       obsMagErr2GO[obsFitUseGO])\n            np.multiply.at(magdLdWashSlope,\n                           (expWashIndexGOF,obsBandIndexGO[obsFitUseGO]),\n                           objMagStdMeanErr2GO[obsFitUseGO])\n            np.add.at(partialArray[self.fgcmPars.parQESysSlopeLoc:\n                                       (self.fgcmPars.parQESysSlopeLoc +\n                                        self.fgcmPars.nWashIntervals)],\n                      expWashIndexGOF,\n                      deltaMagWeightedGOF * (\n                    (self.fgcmPars.expMJD[obsExpIndexGO[obsFitUseGO]] -\n                     self.fgcmPars.washMJDs[expWashIndexGOF]) -\n                    magdLdWashSlope[expWashIndexGOF,\n                                    obsBandIndexGO[obsFitUseGO]]))\n            partialArray[self.fgcmPars.parQESysSlopeLoc +\n                         uWashIndex] *= (2.0 / unitDict['qeSysSlopeUnit'])\n            partialArray[self.fgcmPars.nFitPars +\n                         self.fgcmPars.parQESysSlopeLoc +\n                         uWashIndex] += 1\n\n\n        # note that this store doesn't need locking because we only access\n        #  a given array from a single process\n\n        totalArr = snmm.getArray(self.totalHandleDict[thisCore])\n        totalArr[:] = totalArr[:] + partialArray\n\n        # and we're done\n        return None\n\n    def __getstate__(self):\n        # Don't try to pickle the logger.\n\n        state = self.__dict__.copy()\n        del state['fgcmLog']\n        return state\n", "meta": {"hexsha": "d1d56ca89d805858d582c5655a1fdd0cbd2f3055", "size": 48875, "ext": "py", "lang": "Python", "max_stars_repo_path": "fgcm/fgcmChisq.py", "max_stars_repo_name": "gcmshadow/fgcm", "max_stars_repo_head_hexsha": "f94231d90dc5f1b5711af3b1e259d26a6144cc15", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "fgcm/fgcmChisq.py", "max_issues_repo_name": "gcmshadow/fgcm", "max_issues_repo_head_hexsha": "f94231d90dc5f1b5711af3b1e259d26a6144cc15", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "fgcm/fgcmChisq.py", "max_forks_repo_name": "gcmshadow/fgcm", "max_forks_repo_head_hexsha": "f94231d90dc5f1b5711af3b1e259d26a6144cc15", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.1956521739, "max_line_length": 185, "alphanum_fraction": 0.5530434783, "include": true, "reason": "import numpy", "num_tokens": 12290, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.1824255260288117, "lm_q1q2_score": 0.09192534822793161}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Face Recognition\n# \n# Welcome! In this assignment, you're going to build a face recognition system. Many of the ideas presented here are from [FaceNet](https://arxiv.org/pdf/1503.03832.pdf). In the lecture, you also encountered [DeepFace](https://research.fb.com/wp-content/uploads/2016/11/deepface-closing-the-gap-to-human-level-performance-in-face-verification.pdf).\n# \n# Face recognition problems commonly fall into one of two categories: \n# \n# **Face Verification** \"Is this the claimed person?\" For example, at some airports, you can pass through customs by letting a system scan your passport and then verifying that you (the person carrying the passport) are the correct person. A mobile phone that unlocks using your face is also using face verification. This is a 1:1 matching problem.\n# \n# **Face Recognition** \"Who is this person?\" For example, the video lecture showed a [face recognition video](https://www.youtube.com/watch?v=wr4rx0Spihs) of Baidu employees entering the office without needing to otherwise identify themselves. This is a 1:K matching problem.\n# \n# FaceNet learns a neural network that encodes a face image into a vector of 128 numbers. By comparing two such vectors, you can then determine if two pictures are of the same person.\n# \n# By the end of this assignment, you'll be able to: \n# \n# * Differentiate between face recognition and face verification\n# * Implement one-shot learning to solve a face recognition problem\n# * Apply the triplet loss function to learn a network's parameters in the context of face recognition\n# * Explain how to pose face recognition as a binary classification problem\n# * Map face images into 128-dimensional encodings using a pretrained model\n# * Perform face verification and face recognition with these encodings\n# \n# **Channels-last notation**\n# \n# For this assignment, you'll be using a pre-trained model which represents ConvNet activations using a \"channels last\" convention, as used during the lecture and in previous programming assignments.\n# \n# In other words, a batch of images will be of shape $(m, n_H, n_W, n_C)$. \n\n# ## Table of Contents\n# \n# - [1 - Packages](#1)\n# - [2 - Naive Face Verification](#2)\n# - [3 - Encoding Face Images into a 128-Dimensional Vector](#3)\n#     - [3.1 - Using a ConvNet to Compute Encodings](#3-1)\n#     - [3.2 - The Triplet Loss](#3-2)\n#         - [Exercise 1 - triplet_loss](#ex-1)\n# - [4 - Loading the Pre-trained Model](#4)\n# - [5 - Applying the Model](#5)\n#     - [5.1 - Face Verification](#5-1)\n#         - [Exercise 2 - verify](#ex-2)\n#     - [5.2 - Face Recognition](#5-2)\n#         - [Exercise 3 - who_is_it](#ex-3)\n# - [6 - References](#6)\n\n# <a name='1'></a>\n# ## 1 - Packages\n# \n# Go ahead and run the cell below to import the packages you'll need.\n\n# In[1]:\n\n\nfrom tensorflow.keras.models import Sequential\nfrom tensorflow.keras.layers import Conv2D, ZeroPadding2D, Activation, Input, concatenate\nfrom tensorflow.keras.models import Model\nfrom tensorflow.keras.layers import BatchNormalization\nfrom tensorflow.keras.layers import MaxPooling2D, AveragePooling2D\nfrom tensorflow.keras.layers import Concatenate\nfrom tensorflow.keras.layers import Lambda, Flatten, Dense\nfrom tensorflow.keras.initializers import glorot_uniform\nfrom tensorflow.keras.layers import Layer\nfrom tensorflow.keras import backend as K\nK.set_image_data_format('channels_last')\nimport os\nimport numpy as np\nfrom numpy import genfromtxt\nimport pandas as pd\nimport tensorflow as tf\nimport PIL\n\nget_ipython().run_line_magic('matplotlib', 'inline')\nget_ipython().run_line_magic('load_ext', 'autoreload')\nget_ipython().run_line_magic('autoreload', '2')\n\n\n# <a name='2'></a>\n# ## 2 - Naive Face Verification\n# \n# In Face Verification, you're given two images and you have to determine if they are of the same person. The simplest way to do this is to compare the two images pixel-by-pixel. If the distance between the raw images is below a chosen threshold, it may be the same person!\n# \n# <img src=\"images/pixel_comparison.png\" style=\"width:380px;height:150px;\">\n# <caption><center> <u> <font color='purple'> <b>Figure 1</b> </u></center></caption>\n# \n# Of course, this algorithm performs poorly, since the pixel values change dramatically due to variations in lighting, orientation of the person's face, minor changes in head position, and so on.\n# \n# You'll see that rather than using the raw image, you can learn an encoding, $f(img)$.\n# \n# By using an encoding for each image, an element-wise comparison produces a more accurate judgement as to whether two pictures are of the same person.\n\n# <a name='3'></a>\n# ## 3 - Encoding Face Images into a 128-Dimensional Vector\n# \n# <a name='3-1'></a>\n# ### 3.1 - Using a ConvNet to Compute Encodings\n# \n# The FaceNet model takes a lot of data and a long time to train. So following the common practice in applied deep learning, you'll load weights that someone else has already trained. The network architecture follows the Inception model from [Szegedy *et al*..](https://arxiv.org/abs/1409.4842) An Inception network implementation has been provided for you, and you can find it in the file `inception_blocks_v2.py` to get a closer look at how it is implemented.  \n# \n# *Hot tip:* Go to \"File->Open...\" at the top of this notebook. This opens the file directory that contains the `.py` file).\n# \n# The key things to be aware of are:\n# \n# - This network uses 160x160 dimensional RGB images as its input. Specifically, a face image (or batch of $m$ face images) as a tensor of shape $(m, n_H, n_W, n_C) = (m, 160, 160, 3)$\n# - The input images are originally of shape 96x96, thus, you need to scale them to 160x160. This is done in the `img_to_encoding()` function.\n# - The output is a matrix of shape $(m, 128)$ that encodes each input face image into a 128-dimensional vector\n# \n# Run the cell below to create the model for face images!\n\n# In[2]:\n\n\nfrom tensorflow.keras.models import model_from_json\n\njson_file = open('keras-facenet-h5/model.json', 'r')\nloaded_model_json = json_file.read()\njson_file.close()\nmodel = model_from_json(loaded_model_json)\nmodel.load_weights('keras-facenet-h5/model.h5')\n\n\n# Now summarize the input and output shapes: \n\n# In[3]:\n\n\nprint(model.inputs)\nprint(model.outputs)\n\n\n# By using a 128-neuron fully connected layer as its last layer, the model ensures that the output is an encoding vector of size 128. You then use the encodings to compare two face images as follows:\n# \n# <img src=\"images/distance_kiank.png\\\" style=\"width:680px;height:250px;\">\n# <caption><center> <u> <font color='purple'> <b>Figure 2:</b> <br> </u> <font color='purple'>By computing the distance between two encodings and thresholding, you can determine if the two pictures represent the same person</center></caption>\n# \n# So, an encoding is a good one if:\n# \n# - The encodings of two images of the same person are quite similar to each other.\n# - The encodings of two images of different persons are very different.\n# \n# The triplet loss function formalizes this, and tries to \"push\" the encodings of two images of the same person (Anchor and Positive) closer together, while \"pulling\" the encodings of two images of different persons (Anchor, Negative) further apart.\n#     \n# <img src=\"images/triplet_comparison.png\" style=\"width:280px;height:150px;\"><br>\n# <caption><center> <u> <font color='purple'> <b>Figure 3: </b> <br> </u> <font color='purple'> In the next section,  you'll call the pictures from left to right: Anchor (A), Positive (P), Negative (N)</center></caption>\n\n# <a name='3-2'></a>\n# ### 3.2 - The Triplet Loss\n# \n# **Important Note**: Since you're using a pretrained model, you won't actually need to implement the triplet loss function in this assignment. *However*, the triplet loss is the main ingredient of the face recognition algorithm, and you'll need to know how to use it for training your own FaceNet model, as well as other types of image similarity problems. Therefore, you'll implement it below, for fun and edification. :) \n# \n# For an image $x$, its encoding is denoted as $f(x)$, where $f$ is the function computed by the neural network.\n# \n# <img src=\"images/f_x.png\" style=\"width:380px;height:150px;\">\n# \n# Training will use triplets of images $(A, P, N)$:\n# \n# - A is an \"Anchor\" image--a picture of a person.\n# - P is a \"Positive\" image--a picture of the same person as the Anchor image.\n# - N is a \"Negative\" image--a picture of a different person than the Anchor image.\n# \n# These triplets are picked from the training dataset. $(A^{(i)}, P^{(i)}, N^{(i)})$ is used here to denote the $i$-th training example.\n# \n# You'd like to make sure that an image $A^{(i)}$ of an individual is closer to the Positive $P^{(i)}$ than to the Negative image $N^{(i)}$) by at least a margin $\\alpha$:\n# \n# $$\n# || f\\left(A^{(i)}\\right)-f\\left(P^{(i)}\\right)||_{2}^{2}+\\alpha<|| f\\left(A^{(i)}\\right)-f\\left(N^{(i)}\\right)||_{2}^{2}\n# $$\n# \n# \n# You would thus like to minimize the following \"triplet cost\":\n# \n# $$\\mathcal{J} = \\sum^{m}_{i=1} \\large[ \\small \\underbrace{\\mid \\mid f(A^{(i)}) - f(P^{(i)}) \\mid \\mid_2^2}_\\text{(1)} - \\underbrace{\\mid \\mid f(A^{(i)}) - f(N^{(i)}) \\mid \\mid_2^2}_\\text{(2)} + \\alpha \\large ] \\small_+ \\tag{3}$$\n# Here, the notation \"$[z]_+$\" is used to denote $max(z,0)$.\n# \n# **Notes**:\n# \n# - The term (1) is the squared distance between the anchor \"A\" and the positive \"P\" for a given triplet; you want this to be small.\n# - The term (2) is the squared distance between the anchor \"A\" and the negative \"N\" for a given triplet, you want this to be relatively large. It has a minus sign preceding it because minimizing the negative of the term is the same as maximizing that term.\n# - $\\alpha$ is called the margin. It's a hyperparameter that you pick manually. You'll use $\\alpha = 0.2$.\n# \n# Most implementations also rescale the encoding vectors to haven L2 norm equal to one (i.e., $\\mid \\mid f(img)\\mid \\mid_2$=1); you won't have to worry about that in this assignment.\n# \n# <a name='ex-1'></a>\n# ### Exercise 1 - triplet_loss\n# \n# Implement the triplet loss as defined by formula (3). These are the 4 steps:\n# \n# 1. Compute the distance between the encodings of \"anchor\" and \"positive\": $\\mid \\mid f(A^{(i)}) - f(P^{(i)}) \\mid \\mid_2^2$\n# 2. Compute the distance between the encodings of \"anchor\" and \"negative\": $\\mid \\mid f(A^{(i)}) - f(N^{(i)}) \\mid \\mid_2^2$\n# 3. Compute the formula per training example: $ \\mid \\mid f(A^{(i)}) - f(P^{(i)}) \\mid \\mid_2^2 - \\mid \\mid f(A^{(i)}) - f(N^{(i)}) \\mid \\mid_2^2 + \\alpha$\n# 4. Compute the full formula by taking the max with zero and summing over the training examples:$$\\mathcal{J} = \\sum^{m}_{i=1} \\large[ \\small \\mid \\mid f(A^{(i)}) - f(P^{(i)}) \\mid \\mid_2^2 - \\mid \\mid f(A^{(i)}) - f(N^{(i)}) \\mid \\mid_2^2+ \\alpha \\large ] \\small_+ \\tag{3}$$\n# \n# *Hints*:\n# \n# - Useful functions: `tf.reduce_sum()`, `tf.square()`, `tf.subtract()`, `tf.add()`, `tf.maximum()`.\n# \n# - For steps 1 and 2, sum over the entries of $\\mid \\mid f(A^{(i)}) - f(P^{(i)}) \\mid \\mid_2^2$ and $\\mid \\mid     f(A^{(i)}) - f(N^{(i)}) \\mid \\mid_2^2$.\n# \n# - For step 4, you will sum over the training examples.\n# \n# *Additional Hints*:\n# \n# - Recall that the square of the L2 norm is the sum of the squared differences: $||x - y||_{2}^{2} = \\sum_{i=1}^{N}(x_{i} - y_{i})^{2}$\n# \n# - Note that the anchor, positive and negative encodings are of shape (*m*,128), where *m* is the number of training examples and 128 is the number of elements used to encode a single example.\n# \n# - For steps 1 and 2, maintain the number of *m* training examples and sum along the 128 values of each encoding. `tf.reduce_sum` has an axis parameter. This chooses along which axis the sums are applied.\n# \n# - Note that one way to choose the last axis in a tensor is to use negative indexing (axis=-1).\n# \n# - In step 4, when summing over training examples, the result will be a single scalar value.\n# \n# - For `tf.reduce_sum` to sum across all axes, keep the default value axis=None.\n\n# In[18]:\n\n\n# UNQ_C1(UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: triplet_loss\n\ndef triplet_loss(y_true, y_pred, alpha = 0.2):\n    \"\"\"\n    Implementation of the triplet loss as defined by formula (3)\n    \n    Arguments:\n    y_true -- true labels, required when you define a loss in Keras, you don't need it in this function.\n    y_pred -- python list containing three objects:\n            anchor -- the encodings for the anchor images, of shape (None, 128)\n            positive -- the encodings for the positive images, of shape (None, 128)\n            negative -- the encodings for the negative images, of shape (None, 128)\n    \n    Returns:\n    loss -- real number, value of the loss\n    \"\"\"\n    \n    anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\n    \n    ### START CODE HERE\n    #(≈ 4 lines)\n    # Step 1: Compute the (encoding) distance between the anchor and the positive\n    pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=-1)\n    # Step 2: Compute the (encoding) distance between the anchor and the negative\n    neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=-1)\n    # Step 3: subtract the two previous distances and add alpha.\n    basic_loss = pos_dist - neg_dist + alpha\n    # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\n    loss = tf.reduce_sum(tf.maximum(basic_loss, 0))\n    ### END CODE HERE\n    \n    return loss\n\n\n# In[19]:\n\n\n# BEGIN UNIT TEST\ntf.random.set_seed(1)\ny_true = (None, None, None) # It is not used\ny_pred = (tf.keras.backend.random_normal([3, 128], mean=6, stddev=0.1, seed = 1),\n          tf.keras.backend.random_normal([3, 128], mean=1, stddev=1, seed = 1),\n          tf.keras.backend.random_normal([3, 128], mean=3, stddev=4, seed = 1))\nloss = triplet_loss(y_true, y_pred)\n\nassert type(loss) == tf.python.framework.ops.EagerTensor, \"Use tensorflow functions\"\nprint(\"loss = \" + str(loss))\n\ny_pred_perfect = ([1., 1.], [1., 1.], [1., 1.,])\nloss = triplet_loss(y_true, y_pred_perfect, 5)\nassert loss == 5, \"Wrong value. Did you add the alpha to basic_loss?\"\ny_pred_perfect = ([1., 1.],[1., 1.], [0., 0.,])\nloss = triplet_loss(y_true, y_pred_perfect, 3)\nassert loss == 1., \"Wrong value. Check that pos_dist = 0 and neg_dist = 2 in this example\"\ny_pred_perfect = ([1., 1.],[0., 0.], [1., 1.,])\nloss = triplet_loss(y_true, y_pred_perfect, 0)\nassert loss == 2., \"Wrong value. Check that pos_dist = 2 and neg_dist = 0 in this example\"\ny_pred_perfect = ([0., 0.],[0., 0.], [0., 0.,])\nloss = triplet_loss(y_true, y_pred_perfect, -2)\nassert loss == 0, \"Wrong value. Are you taking the maximum between basic_loss and 0?\"\ny_pred_perfect = ([[1., 0.], [1., 0.]],[[1., 0.], [1., 0.]], [[0., 1.], [0., 1.]])\nloss = triplet_loss(y_true, y_pred_perfect, 3)\nassert loss == 2., \"Wrong value. Are you applying tf.reduce_sum to get the loss?\"\ny_pred_perfect = ([[1., 1.], [2., 0.]], [[0., 3.], [1., 1.]], [[1., 0.], [0., 1.,]])\nloss = triplet_loss(y_true, y_pred_perfect, 1)\nif (loss == 4.):\n    raise Exception('Perhaps you are not using axis=-1 in reduce_sum?')\nassert loss == 5, \"Wrong value. Check your implementation\"\n# END UNIT TEST\n\n\n# **Expected Output**:\n# \n# <table>\n#     <tr>\n#         <td>\n#             <b>loss</b>\n#         </td>\n#         <td>\n#            527.2598\n#         </td>\n#     </tr>\n#     </table>\n\n# <a name='4'></a>\n# ## 4 - Loading the Pre-trained Model\n# \n# FaceNet is trained by minimizing the triplet loss. But since training requires a lot of data and a lot of computation, you won't train it from scratch here. Instead, you'll load a previously trained model in the following cell; which might take a couple of minutes to run.\n\n# In[20]:\n\n\nFRmodel = model\n\n\n# Here are some examples of distances between the encodings between three individuals:\n# \n# <img src=\"images/distance_matrix.png\" style=\"width:380px;height:200px;\"><br>\n# <caption><center> <u> <font color='purple'> <b>Figure 4:</b></u> <br>  <font color='purple'> Example of distance outputs between three individuals' encodings</center></caption>\n# \n# Now use this model to perform face verification and face recognition!\n\n# <a name='5'></a>\n# ## 5 - Applying the Model\n# \n# You're building a system for an office building where the building manager would like to offer facial recognition to allow the employees to enter the building.\n# \n# You'd like to build a face verification system that gives access to a list of people. To be admitted, each person has to swipe an identification card at the entrance. The face recognition system then verifies that they are who they claim to be.\n# \n# <a name='5-1'></a>\n# ### 5.1 - Face Verification\n# \n# Now you'll build a database containing one encoding vector for each person who is allowed to enter the office. To generate the encoding, you'll use `img_to_encoding(image_path, model)`, which runs the forward propagation of the model on the specified image.\n# \n# Run the following code to build the database (represented as a Python dictionary). This database maps each person's name to a 128-dimensional encoding of their face.\n\n# In[21]:\n\n\n#tf.keras.backend.set_image_data_format('channels_last')\ndef img_to_encoding(image_path, model):\n    img = tf.keras.preprocessing.image.load_img(image_path, target_size=(160, 160))\n    img = np.around(np.array(img) / 255.0, decimals=12)\n    x_train = np.expand_dims(img, axis=0)\n    embedding = model.predict_on_batch(x_train)\n    return embedding / np.linalg.norm(embedding, ord=2)\n\n\n# In[22]:\n\n\ndatabase = {}\ndatabase[\"danielle\"] = img_to_encoding(\"images/danielle.png\", FRmodel)\ndatabase[\"younes\"] = img_to_encoding(\"images/younes.jpg\", FRmodel)\ndatabase[\"tian\"] = img_to_encoding(\"images/tian.jpg\", FRmodel)\ndatabase[\"andrew\"] = img_to_encoding(\"images/andrew.jpg\", FRmodel)\ndatabase[\"kian\"] = img_to_encoding(\"images/kian.jpg\", FRmodel)\ndatabase[\"dan\"] = img_to_encoding(\"images/dan.jpg\", FRmodel)\ndatabase[\"sebastiano\"] = img_to_encoding(\"images/sebastiano.jpg\", FRmodel)\ndatabase[\"bertrand\"] = img_to_encoding(\"images/bertrand.jpg\", FRmodel)\ndatabase[\"kevin\"] = img_to_encoding(\"images/kevin.jpg\", FRmodel)\ndatabase[\"felix\"] = img_to_encoding(\"images/felix.jpg\", FRmodel)\ndatabase[\"benoit\"] = img_to_encoding(\"images/benoit.jpg\", FRmodel)\ndatabase[\"arnaud\"] = img_to_encoding(\"images/arnaud.jpg\", FRmodel)\n\n\n# Load the images of Danielle and Kian: \n\n# In[23]:\n\n\ndanielle = tf.keras.preprocessing.image.load_img(\"images/danielle.png\", target_size=(160, 160))\nkian = tf.keras.preprocessing.image.load_img(\"images/kian.jpg\", target_size=(160, 160))\n\n\n# In[24]:\n\n\nnp.around(np.array(kian) / 255.0, decimals=12).shape\n\n\n# In[25]:\n\n\nkian\n\n\n# In[26]:\n\n\nnp.around(np.array(danielle) / 255.0, decimals=12).shape\n\n\n# In[27]:\n\n\ndanielle\n\n\n# Now, when someone shows up at your front door and swipes their ID card (thus giving you their name), you can look up their encoding in the database, and use it to check if the person standing at the front door matches the name on the ID.\n# \n# <a name='ex-2'></a>\n# ### Exercise 2 - verify\n# \n# Implement the `verify()` function, which checks if the front-door camera picture (`image_path`) is actually the person called \"identity\". You will have to go through the following steps:\n# \n# - Compute the encoding of the image from `image_path`.\n# - Compute the distance between this encoding and the encoding of the identity image stored in the database.\n# - Open the door if the distance is less than 0.7, else do not open it.\n# \n# As presented above, you should use the L2 distance `np.linalg.norm`.\n# \n# **Note**: In this implementation, compare the L2 distance, not the square of the L2 distance, to the threshold 0.7.\n# \n# *Hints*:\n# \n# - `identity` is a string that is also a key in the database dictionary.\n# - `img_to_encoding` has two parameters: the image_path and model.\n\n# In[30]:\n\n\n# UNQ_C2(UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: verify\n\ndef verify(image_path, identity, database, model):\n    \"\"\"\n    Function that verifies if the person on the \"image_path\" image is \"identity\".\n    \n    Arguments:\n        image_path -- path to an image\n        identity -- string, name of the person you'd like to verify the identity. Has to be an employee who works in the office.\n        database -- python dictionary mapping names of allowed people's names (strings) to their encodings (vectors).\n        model -- your Inception model instance in Keras\n    \n    Returns:\n        dist -- distance between the image_path and the image of \"identity\" in the database.\n        door_open -- True, if the door should open. False otherwise.\n    \"\"\"\n    ### START CODE HERE\n    # Step 1: Compute the encoding for the image. Use img_to_encoding() see example above. (≈ 1 line)\n    encoding = img_to_encoding(image_path, model)\n    # Step 2: Compute distance with identity's image (≈ 1 line)\n    dist = np.linalg.norm(database[identity] - encoding)\n    # Step 3: Open the door if dist < 0.7, else don't open (≈ 3 lines)\n    if dist < 0.7:\n        print(\"It's \" + str(identity) + \", welcome in!\")\n        door_open = True\n    else:\n        print(\"It's not \" + str(identity) + \", please go away\")\n        door_open = False\n    ### END CODE HERE        \n    return dist, door_open\n\n\n# Younes is trying to enter the office and the camera takes a picture of him (\"images/camera_0.jpg\"). Let's run your verification algorithm on this picture:\n# \n# <img src=\"images/camera_0.jpg\\\" style=\"width:100px;height:100px;\">\n\n# In[31]:\n\n\n# BEGIN UNIT TEST\nassert(np.allclose(verify(\"images/camera_1.jpg\", \"bertrand\", database, FRmodel), (0.54364836, True)))\nassert(np.allclose(verify(\"images/camera_3.jpg\", \"bertrand\", database, FRmodel), (0.38616243, True)))\nassert(np.allclose(verify(\"images/camera_1.jpg\", \"younes\", database, FRmodel), (1.3963861, False)))\nassert(np.allclose(verify(\"images/camera_3.jpg\", \"younes\", database, FRmodel), (1.3872949, False)))\n\nverify(\"images/camera_0.jpg\", \"younes\", database, FRmodel)\n# END UNIT TEST\n\n\n# **Expected Output**:\n# \n# <table>\n#     <tr>\n#         <td>\n#             <b>It's Younes, welcome in!</b>\n#         </td>\n#         <td>\n#            (0.5992946, True)\n#         </td>\n#     </tr>\n#     </table>\n\n# Benoit, who does not work in the office, stole Kian's ID card and tried to enter the office. Naughty Benoit! The camera took a picture of Benoit (\"images/camera_2.jpg). \n# \n# <img src=\"images/camera_2.jpg\" style=\"width:100px;height:100px;\">\n# \n# Run the verification algorithm to check if Benoit can enter.\n\n# In[32]:\n\n\nverify(\"images/camera_2.jpg\", \"kian\", database, FRmodel)\n\n\n# **Expected Output**:\n# \n# <table>\n#     <tr>\n#         <td>\n#             <b>It's not Kian, please go away</b>\n#         </td>\n#         <td>\n#            (1.0259346, False)\n#         </td>\n#     </tr>\n#     </table>\n\n# <a name='5-2'></a>\n# ### 5.2 - Face Recognition\n# \n# Your face verification system is mostly working. But since Kian got his ID card stolen, when he came back to the office the next day he couldn't get in!\n# \n# To solve this, you'd like to change your face verification system to a face recognition system. This way, no one has to carry an ID card anymore. An authorized person can just walk up to the building, and the door will unlock for them!\n# \n# You'll implement a face recognition system that takes as input an image, and figures out if it is one of the authorized persons (and if so, who). Unlike the previous face verification system, you will no longer get a person's name as one of the inputs.\n# \n# <a name='ex-3'></a>\n# ### Exercise 3 - who_is_it\n# \n# Implement `who_is_it()` with the following steps:\n# \n# - Compute the target encoding of the image from `image_path`\n# - Find the encoding from the database that has smallest distance with the target encoding.\n# - Initialize the `min_dist` variable to a large enough number (100). This helps you keep track of the closest encoding to the input's encoding.\n# - Loop over the database dictionary's names and encodings. To loop use for (name, db_enc) in `database.items()`.\n# - Compute the L2 distance between the target \"encoding\" and the current \"encoding\" from the database. If this distance is less than the min_dist, then set min_dist to dist, and identity to name.\n\n# In[33]:\n\n\n# UNQ_C3(UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: who_is_it\n\ndef who_is_it(image_path, database, model):\n    \"\"\"\n    Implements face recognition for the office by finding who is the person on the image_path image.\n    \n    Arguments:\n        image_path -- path to an image\n        database -- database containing image encodings along with the name of the person on the image\n        model -- your Inception model instance in Keras\n    \n    Returns:\n        min_dist -- the minimum distance between image_path encoding and the encodings from the database\n        identity -- string, the name prediction for the person on image_path\n    \"\"\"\n    \n    ### START CODE HERE\n\n    ## Step 1: Compute the target \"encoding\" for the image. Use img_to_encoding() see example above. ## (≈ 1 line)\n    encoding =  img_to_encoding(image_path, model)\n    \n    ## Step 2: Find the closest encoding ##\n    \n    # Initialize \"min_dist\" to a large value, say 100 (≈1 line)\n    min_dist = 100\n    \n    # Loop over the database dictionary's names and encodings.\n    for (name, db_enc) in database.items():\n        \n        # Compute L2 distance between the target \"encoding\" and the current db_enc from the database. (≈ 1 line)\n        dist = np.linalg.norm(db_enc - encoding)\n\n        # If this distance is less than the min_dist, then set min_dist to dist, and identity to name. (≈ 3 lines)\n        if dist < min_dist:\n            min_dist = dist\n            identity = name\n    ### END CODE HERE\n    \n    if min_dist > 0.7:\n        print(\"Not in the database.\")\n    else:\n        print (\"it's \" + str(identity) + \", the distance is \" + str(min_dist))\n        \n    return min_dist, identity\n\n\n# Younes is at the front door and the camera takes a picture of him (\"images/camera_0.jpg\"). Let's see if your `who_it_is()` algorithm identifies Younes.\n\n# In[34]:\n\n\n# BEGIN UNIT TEST\n# Test 1 with Younes pictures \nwho_is_it(\"images/camera_0.jpg\", database, FRmodel)\n\n# Test 2 with Younes pictures \ntest1 = who_is_it(\"images/camera_0.jpg\", database, FRmodel)\nassert np.isclose(test1[0], 0.5992946)\nassert test1[1] == 'younes'\n\n# Test 3 with Younes pictures \ntest2 = who_is_it(\"images/younes.jpg\", database, FRmodel)\nassert np.isclose(test2[0], 0.0)\nassert test2[1] == 'younes'\n# END UNIT TEST\n\n\n# **Expected Output**:\n# \n# <table>\n#     <tr>\n#         <td>\n#             <b>it's Younes, the distance is 0.5992946</b>\n#         </td>\n#         <td>\n#            (0.5992946, 'younes')\n#         </td>\n#     </tr>\n#     </table>\n# \n# You can change \"camera_0.jpg\" (picture of Younes) to \"camera_1.jpg\" (picture of Bertrand) and see the result.\n\n# **Congratulations**! \n# You've completed this assignment, and your face recognition system is working well! It not only lets in authorized persons, but now people don't need to carry an ID card around anymore!\n# \n# You've now seen how a state-of-the-art face recognition system works, and can describe the difference between face recognition and face verification. Here's a quick recap of what you've accomplished: \n# \n# - Posed face recognition as a binary classification problem\n# - Implemented one-shot learning for a face recognition problem\n# - Applied the triplet loss function to learn a network's parameters in the context of face recognition\n# - Mapped face images into 128-dimensional encodings using a pretrained model\n# - Performed face verification and face recognition with these encodings\n# \n# Great work! \n\n# <font color='blue'>\n#     \n# **What you should remember**:\n# \n# - Face verification solves an easier 1:1 matching problem; face recognition addresses a harder 1:K matching problem.\n#     \n# - Triplet loss is an effective loss function for training a neural network to learn an encoding of a face image.\n#     \n# - The same encoding can be used for verification and recognition. Measuring distances between two images' encodings allows you to determine whether they are pictures of the same person.\n\n# **Ways to improve your facial recognition model**:\n# \n# Although you won't implement these here, here are some ways to further improve the algorithm:\n# \n# - Put more images of each person (under different lighting conditions, taken on different days, etc.) into the database. Then, given a new image, compare the new face to multiple pictures of the person. This would increase accuracy.\n# \n# - Crop the images to contain just the face, and less of the \"border\" region around the face. This preprocessing removes some of the irrelevant pixels around the face, and also makes the algorithm more robust.\n\n# <a name='6'></a>\n# ## 6 - References\n# 1. Florian Schroff, Dmitry Kalenichenko, James Philbin (2015). [FaceNet: A Unified Embedding for Face Recognition and Clustering](https://arxiv.org/pdf/1503.03832.pdf)\n# \n# 2. Yaniv Taigman, Ming Yang, Marc'Aurelio Ranzato, Lior Wolf (2014). [DeepFace: Closing the gap to human-level performance in face verification](https://research.fb.com/wp-content/uploads/2016/11/deepface-closing-the-gap-to-human-level-performance-in-face-verification.pdf)\n# \n# 3. This implementation also took a lot of inspiration from the official FaceNet github repository: https://github.com/davidsandberg/facenet\n# \n# 4. Further inspiration was found here: https://machinelearningmastery.com/how-to-develop-a-face-recognition-system-using-facenet-in-keras-and-an-svm-classifier/\n# \n# 5. And here: https://github.com/nyoki-mtl/keras-facenet/blob/master/notebook/tf_to_keras.ipynb\n", "meta": {"hexsha": "bd46b1f3d6b273153c1cb2da9bd4b44322a39fa0", "size": 29722, "ext": "py", "lang": "Python", "max_stars_repo_path": "4 - Convolutional Neural Networks/Face_Recognition.py", "max_stars_repo_name": "pouyalj/DeepLearningCoursera", "max_stars_repo_head_hexsha": "4c0d79a53bbdd24fbb77503fed35e73d24949be2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-01T00:14:18.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-01T00:14:18.000Z", "max_issues_repo_path": "4 - Convolutional Neural Networks/Face_Recognition.py", "max_issues_repo_name": "pouyalj/DeepLearningCoursera", "max_issues_repo_head_hexsha": "4c0d79a53bbdd24fbb77503fed35e73d24949be2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "4 - Convolutional Neural Networks/Face_Recognition.py", "max_forks_repo_name": "pouyalj/DeepLearningCoursera", "max_forks_repo_head_hexsha": "4c0d79a53bbdd24fbb77503fed35e73d24949be2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.2389649924, "max_line_length": 463, "alphanum_fraction": 0.6955790324, "include": true, "reason": "import numpy,from numpy", "num_tokens": 8089, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.19193279106941585, "lm_q1q2_score": 0.09147126259553963}}
{"text": "\"\"\"\nDefines comparer functions used by FormulaGrader and its subclasses.\n\nSimple Comparer Functions\n=========================\n\nA comparer function must have signature\n`comparer_func(comparer_params_eval, student_eval, utils)` and should return\nTrue, False, 'partial', or a dictionary with required key 'grade_decimal' and\noptional key 'msg'. When `FormulaGrader` (or its subclasses) call your custom\ncomparer function, `comparer_func`'s argument values are:\n\n- `comparer_params_eval`: The `comparer_params` list, numerically evaluated\n  according to variable and function sampling.\n- `student_eval`: The student's input, numerically evaluated according to\n  variable and function sampling.\n- `utils`: A convenience object that may be helpful when writing custom\n  comparer functions. It has attributes:\n\n    - `utils.tolerance`: The tolerance specified in grader configuration,\n      `0.01%` by default\n    - `utils.within_tolerance(x, y)`: checks that `y` is within specified\n      tolerance of `x`. Can handle scalars, vectors, and matrices.\n      If tolerance was specified as a percentage, then checks that\n      `|x-y| < tolerance * x`.\n\n    Comparer functions used inside `MatrixGrader` have the following additional\n    `utils` method:\n\n    - `utils.validate_shape(student_eval, shape)`: Checks that `student_eval`\n      has specified `shape`, where `shape` is a Numpy shape tuple.\n\nA comparer function must return either:\n\n  - a boolean, or\n  - a dictionary with keys:\n      - `'grade_decimal'`: number between 0 and 1 (required)\n      - `'ok'`: `True` or `False` or `'partial'` (optional, inferred from\n        grade_decimal by default)\n      - `'msg'`: a feedback message (optional, defaults to `''`)\n\n\nNOTE: doctests in this module show how the comparer function would be used\n      inside a grader\n\nCorrelated Comparers\n====================\nSee ./baseclasses.py and ./linear_comparer.py for examples.\n\"\"\"\nfrom __future__ import print_function, division, absolute_import, unicode_literals\n\nfrom numbers import Number\nimport numpy as np\n\nimport six\nfrom voluptuous import Schema, Required, Any, Range, All\n\nfrom mitxgraders.exceptions import InputTypeError, StudentFacingError\nfrom mitxgraders.helpers.validatorfuncs import is_callable, Nullable, text_string\nfrom mitxgraders.helpers.calc.mathfuncs import is_nearly_zero\nfrom mitxgraders.helpers.calc.math_array import are_same_length_vectors, is_vector\nfrom mitxgraders.comparers.baseclasses import Comparer, CorrelatedComparer\n\ndef identity_transform(x):\n    \"\"\"\n    Returns the input.\n\n    Note: used instead of lambdas because it prints a nice name.\n    \"\"\"\n    return x\n\nclass EqualityComparer(Comparer):\n    \"\"\"\n    This comparer checks for equality between the student and instructor results,\n    up to a desired tolerance. If desired, a transforming function can be applied\n    before the comparison is carried out.\n\n    comparer_params: ['expect']\n\n    By default, equality_comparer is used in FormulaGrader, NumericalGrader and MatrixGrader.\n    >>> from mitxgraders import *\n    >>> equality_comparer == EqualityComparer()\n    True\n    >>> grader = FormulaGrader(\n    ...     answers='2*x',\n    ...     variables=['x']\n    ... )\n    >>> grader(None, 'x')['ok']\n    False\n    >>> grader(None, 'x*2')['ok']\n    True\n\n    The following example applies cosine to the expected answer and student input\n    before comparison:\n    >>> import numpy as np\n    >>> grader = FormulaGrader(\n    ...     answers={\n    ...         'comparer': EqualityComparer(transform=np.cos),\n    ...         'comparer_params': ['x']\n    ...     },\n    ...     variables=['x']\n    ... )\n    >>> grader(None, 'x')['ok']\n    True\n    >>> grader(None, '-x')['ok']\n    True\n    >>> grader(None, 'x + 2*pi')['ok']\n    True\n    >>> grader(None, 'x + pi')['ok']\n    False\n\n    The following example takes the norm of the expected answer and student input\n    before comparison. Note the different method of changing the comparer.\n    >>> MatrixGrader.set_default_comparer(EqualityComparer(transform=np.linalg.norm))\n    >>> grader = MatrixGrader(\n    ...     answers='[1, 0, 0]'\n    ... )\n    >>> grader(None, '[1, 0, 0]')['ok']\n    True\n    >>> grader(None, '[0, 1, 0]')['ok']\n    True\n    >>> grader(None, '[1/sqrt(2), 0, 1/sqrt(2)]')['ok']\n    True\n    >>> MatrixGrader.reset_default_comparer()\n\n    FormulaGrader and MatrixGrader both have set_default_comparer() and\n    reset_default_comparer() methods.\n\n    \"\"\"\n    schema_config = Schema({\n        Required('transform', default=None): All(\n            Nullable(is_callable),\n            # if f is None, coerce to identity function\n            lambda f: identity_transform if f is None else f\n        )\n    })\n\n    @staticmethod\n    def validate(expected_eval, student_eval, utils):\n        if hasattr(utils, 'validate_shape'):\n            # in numpy, scalars have empty tuples as their shapes\n            shape = tuple() if isinstance(expected_eval, Number) else expected_eval.shape\n            utils.validate_shape(student_eval, shape)\n\n    def __call__(self, comparer_params_eval, student_eval, utils):\n        expected_eval = comparer_params_eval[0]\n        self.validate(expected_eval, student_eval, utils)\n\n        transform = self.config['transform']\n        expected_eval = transform(expected_eval)\n        student_eval = transform(student_eval)\n\n        return utils.within_tolerance(expected_eval, student_eval)\n\nequality_comparer = EqualityComparer()\n\nclass MatrixEntryComparer(CorrelatedComparer):\n    \"\"\"\n    Default comparer for MatrixGrader. Compares student and instructor array\n    evaluations entry-by-entry for equality. Note that despite the name, this comparer\n    works equally well on vectors/matrices/tensors.\n\n    Configuration\n    =============\n        transform (None | function): same as EqualityComparer (default None)\n\n        entry_partial_credit ('proportional' | number): Determines how partial credit\n            is awarded. If set to 'proportional', then credit is proportional to\n            the number of correct array entries. If a numeric value betweem 0 and 1\n            is provided, this flat rate of partial credit is provided as long as\n            some but not all entries are correct. Default is the numeric value 0\n            (no partial credit).\n\n        entry_partial_msg (str): A text string message shown when partial credit\n            is awarded. The string may optionally contain the formatting key {error_indices},\n            which will be replaced with a diagram showing the correct/incorrect entries.\n            To show no message, use the the empty string.\n            Default value is:\n            \"Some array entries are incorrect, marked below:\\n{error_locations}\"\n    \"\"\"\n\n    default_msg = \"Some array entries are incorrect, marked below:\\n{error_locations}\"\n    schema_config = EqualityComparer.schema_config.extend({\n        Required('entry_partial_credit', default=0): Any(All(float, Range(0, 1)), 0, 1, 'proportional'),\n        Required('entry_partial_msg', default=default_msg): text_string\n    })\n\n    @staticmethod\n    def format_message_with_locations(format_string, locs):\n        \"\"\"\n        Returns format_string with {error_locations} replaced by a diagram showing\n        correct/incorrect entries.\n\n        Arguments:\n            format_string: a string that may contain {error_locations} formatting key.\n            locs: a boolean array with False values indicating incorrect entries\n        \"\"\"\n        # Not the most elegant way to do these replacements, but this was what\n        # I came up with to minimize the amount of extra u prefixes in Python 2\n\n        # These are the edX colors, at least as of July 2019\n        bad_str = '<span style=\"color:#b20610\">\\u2717</span>'\n        good_str = '<span style=\"color:#008100\">\\u2713</span>'\n        matrix_as_text = six.text_type(locs).replace(\"  \", \" \").replace(\"[ \", \"[\")\n        matrix_as_text = matrix_as_text.replace(\"True\", good_str).replace(\"False\", bad_str)\n        matrix_as_text = matrix_as_text.replace('\\n', '<br/>')\n        formatted_locs = '<pre>{mat}</pre>'.format(mat=matrix_as_text)\n        return format_string.format(error_locations=formatted_locs)\n\n    @staticmethod\n    def validate(expected_evals, student_evals, utils):\n        for x, y in zip(expected_evals, student_evals):\n            EqualityComparer.validate(x, y, utils)\n\n    def __call__(self, comparer_params_evals, student_evals, utils):\n        expected_evals = [params[0] for params in comparer_params_evals]\n        self.validate(expected_evals, student_evals, utils)\n\n        transform = self.config['transform']\n        expected_evals = [transform(x) for x in expected_evals]\n        student_evals = [transform(x) for x in student_evals]\n        vec_within_tol = np.vectorize(utils.within_tolerance)\n        # comparisons_by_eval is a boolean array of entry-by-entry comparisons,\n        # one for each comparison. Its numpy shape is (n_evals, *eval_shape)\n        comparisons_by_eval = vec_within_tol(expected_evals, student_evals)\n        comparisons_summary = np.all(comparisons_by_eval, axis=0)\n\n        num_entries = comparisons_summary.size\n        percent_correct = np.sum(comparisons_summary).item()/num_entries\n        msg = self.format_message_with_locations(self.config['entry_partial_msg'], comparisons_summary)\n        partial_credit = self.config['entry_partial_credit']\n\n        if percent_correct == 1:\n            return True\n        elif percent_correct == 0:\n            return {'ok': False, 'grade_decimal': 0, 'msg': msg}\n        elif partial_credit == 'proportional':\n            return {'ok': 'partial', 'grade_decimal': percent_correct, 'msg': msg}\n        else:\n            return {'ok': 'partial', 'grade_decimal': partial_credit, 'msg': msg}\n\ndef between_comparer(comparer_params_eval, student_eval, utils):\n    \"\"\"\n    Used to check that input is real and between two parameters.\n\n    comparer_params: ['start', 'stop']\n\n    Example:\n    >>> from mitxgraders import NumericalGrader\n    >>> grader = NumericalGrader(\n    ...     answers={\n    ...         'comparer': between_comparer,\n    ...         'comparer_params': ['1e6', '1e9']\n    ...     }\n    ... )\n    >>> grader(None, '2.5e8')['ok']\n    True\n    >>> grader(None, '0.001e8')['ok']\n    False\n    >>> grader(None, '5e7')['ok']\n    True\n\n    Input must be real:\n    >>> try:\n    ...     grader(None, '5e8+2e6*i')['ok']\n    ... except InputTypeError as error:\n    ...     print(error)\n    Input must be real.\n    \"\"\"\n    start, stop = comparer_params_eval\n\n    if not np.isreal(student_eval):\n        raise InputTypeError(\"Input must be real.\")\n\n    return start <= student_eval <= stop\n\ndef congruence_comparer(comparer_params_eval, student_eval, utils):\n    \"\"\"\n    Compares the student input to a target, moduli a given modulus.\n    Will often set modulus to 2*pi in order to compare angles.\n\n    comparer_params: [target, modulus]\n\n    Example usage:\n    >>> from mitxgraders import FormulaGrader\n    >>> grader = FormulaGrader(\n    ...     answers={\n    ...         'comparer': congruence_comparer,\n    ...         'comparer_params': [\n    ...             'b^2/a', # target\n    ...             'c'      # modulus\n    ...         ]\n    ...     },\n    ...     variables=['a', 'b', 'c']\n    ... )\n    >>> grader(None, 'b^2/a')['ok']\n    True\n    >>> grader(None, 'b^2/a + 1.5*c')['ok']\n    False\n    >>> grader(None, 'b^2/a + 2*c  ')['ok']\n    True\n    \"\"\"\n    expected, modulus = comparer_params_eval\n\n    expected_reduced = expected % modulus\n    input_reduced = student_eval % modulus\n    return utils.within_tolerance(expected_reduced, input_reduced)\n\ndef eigenvector_comparer(comparer_params_eval, student_eval, utils):\n    \"\"\"\n    Used to check that a student's answer is an eigenvector of a matrix\n    with a given eigenvalue. Ignores scaling of the eigenvector.\n\n    comparer_params: [matrix, eigenvalue]\n\n    Example Usage:\n    >>> from mitxgraders import MatrixGrader\n    >>> grader = MatrixGrader(\n    ...     answers={\n    ...         'comparer_params': [\n    ...             '[[1, x], [x, -1]]',    # matrix\n    ...             'sqrt(1+x^2)'           # eigenvalue\n    ...         ],\n    ...         'comparer': eigenvector_comparer\n    ...     },\n    ...     variables=['x']\n    ... )\n    >>> grader(None, '[1+sqrt(1+x^2), x]')['ok']\n    True\n    >>> grader(None, '2*[1+sqrt(1+x^2), x]')['ok']\n    True\n    >>> grader(None, '[1+sqrt(1+x^2), 1]')['ok']\n    False\n    >>> grader(None, '[0, 0]') == {\n    ...     'ok': False,\n    ...     'msg': 'Eigenvectors must be nonzero.',\n    ...     'grade_decimal': 0\n    ... }\n    True\n\n    \"\"\"\n\n    matrix, eigenvalue = comparer_params_eval\n\n    # matrix is square with shape (n, n); student input should have shape (n, )\n    expected_input_shape = (matrix.shape[0], )\n    utils.validate_shape(student_eval, expected_input_shape)\n\n    expected = eigenvalue * student_eval\n    actual = matrix * student_eval\n\n    if utils.within_tolerance(0, np.linalg.norm(student_eval)):\n        return {\n            'ok': False,\n            'grade_decimal': 0,\n            'msg': 'Eigenvectors must be nonzero.'\n        }\n\n    return utils.within_tolerance(actual, expected)\n\ndef vector_span_comparer(comparer_params_eval, student_eval, utils):\n    \"\"\"\n    Check whether student's answer is nonzero and in the span of some given\n    vectors.\n\n    comparer_params: A list of vectors\n\n    Usage\n    =====\n\n    Use a single vector as comparer_params to test whether student input is\n    parallel to a particular vector:\n    >>> from mitxgraders import MatrixGrader\n    >>> grader = MatrixGrader(\n    ...     answers={\n    ...         'comparer_params': [\n    ...             '[3, x, 1 + i]',\n    ...         ],\n    ...         'comparer': vector_span_comparer\n    ...     },\n    ...     variables=['x'],\n    ... )\n    >>> grader(None, '[3, x, 1 + i]')['ok']\n    True\n    >>> grader(None, '[9, 3*x, 3 + 3*i]')['ok']\n    True\n    >>> grader(None, '[9, 3*x, 3 - 3*i]')['ok']\n    False\n\n    Complex scale factors work, too:\n    >>> grader(None, '(4 + 2*i)*[3, x, 1 + i]')['ok']\n    True\n\n    Student input should be nonzero:\n    >>> result = grader(None, '[0, 0, 0]')\n    >>> expected = {\n    ...     'ok': False,\n    ...     'grade_decimal': 0.0,\n    ...     'msg': 'Input should be a nonzero vector.'\n    ... }\n    >>> result == expected\n    True\n\n    Input shape is validated:\n    >>> try:\n    ...     grader(None, '5')\n    ... except InputTypeError as error:\n    ...     print(error)\n    Expected answer to be a vector, but input is a scalar\n\n    Multiple vectors can be provided:\n    >>> grader = MatrixGrader(\n    ...     answers={\n    ...         'comparer_params': [\n    ...             '[1, 1, 0]',    # v0\n    ...             '[0, 1, 2]'     # v1\n    ...         ],\n    ...         'comparer': vector_span_comparer\n    ...     },\n    ... )\n\n    The vector 2*v0 + 3i*v1 = [2, 2+3i, 6i] is in the span of v0 and v1:\n    >>> grader(None, '[2, 2 + 3*i, 6*i]')['ok']\n    True\n\n    The comparer_params should be list of equal-length vectors:\n    >>> grader = MatrixGrader(\n    ...     answers={\n    ...         'comparer_params': [\n    ...             '[1, 1, 0]',\n    ...             '5'\n    ...         ],\n    ...         'comparer': vector_span_comparer\n    ...     },\n    ... )\n    >>> try:\n    ...     grader(None, '[1, 2, 3]')               # doctest: +ELLIPSIS\n    ... except StudentFacingError as error:\n    ...     print(error)\n    Problem Configuration Error: ...to equal-length vectors\n    \"\"\"\n\n    # Validate the comparer params\n    if not are_same_length_vectors(comparer_params_eval):\n        raise StudentFacingError('Problem Configuration Error: comparer_params '\n            'should be a list of strings that evaluate to equal-length vectors')\n\n    # Validate student input shape\n    utils.validate_shape(student_eval, comparer_params_eval[0].shape)\n\n    if utils.within_tolerance(0, np.linalg.norm(student_eval)):\n        return {\n            'ok': False,\n            'grade_decimal': 0,\n            'msg': 'Input should be a nonzero vector.'\n        }\n\n    # Use ordinary least squares to find an approximation to student_eval\n    # that lies within the span of given vectors, then check that the\n    # residual-sum is small in comparison to student input.\n    column_vectors = np.array(comparer_params_eval).transpose()\n    # rcond=-1 uses machine precision for testing singular values\n    # In numpy 1.14+, use rcond=None fo this behavior. (we use 1.6)\n    ols = np.linalg.lstsq(column_vectors, student_eval, rcond=-1)\n    error = np.sqrt(ols[1])\n\n    # Check that error is nearly zero, using student_eval as a reference\n    # when tolerance is specified as a percentage\n    return is_nearly_zero(error, utils.tolerance, reference=student_eval)\n\ndef vector_phase_comparer(comparer_params_eval, student_eval, utils):\n    \"\"\"\n    Check that student input equals a given input (to within tolerance), up to\n    an overall phase factor.\n\n    comparer_params: [target_vector]\n\n    Usage\n    =====\n\n    >>> from mitxgraders import MatrixGrader\n    >>> grader = MatrixGrader(\n    ...     answers={\n    ...         'comparer_params': [\n    ...             '[1, exp(-i*phi)]',\n    ...         ],\n    ...         'comparer': vector_phase_comparer\n    ...     },\n    ...     variables=['phi'],\n    ... )\n\n    >>> grader(None, '[1, exp(-i*phi)]')['ok']\n    True\n    >>> grader(None, '[exp(i*phi/2), exp(-i*phi/2)]')['ok']\n    True\n    >>> grader(None, '[i, exp(i*(pi/2 - phi))]')['ok']\n    True\n\n    >>> grader(None, '[1, exp(+i*phi)]')['ok']\n    False\n    >>> grader(None, '[2, 2*exp(-i*phi)]')['ok']\n    False\n\n    The comparer_params should be list with a single vector:\n    >>> grader = MatrixGrader(\n    ...     answers={\n    ...         'comparer_params': [\n    ...             '[1, 1, 0]',\n    ...             '[0, 1, 1]'\n    ...         ],\n    ...         'comparer': vector_phase_comparer\n    ...     },\n    ... )\n    >>> try:\n    ...     grader(None, '[1, 2, 3]')               # doctest: +ELLIPSIS\n    ... except StudentFacingError as error:\n    ...     print(error)\n    Problem Configuration Error: ...to a single vector.\n    \"\"\"\n    # Validate that author comparer_params evaluate to a single vector\n    if not len(comparer_params_eval) == 1 and is_vector(comparer_params_eval[0]):\n        raise StudentFacingError('Problem Configuration Error: comparer_params '\n            'should be a list of strings that evaluate to a single vector.')\n\n    # We'll check that student input is in the span as target vector and that\n    # it has the same magnitude\n\n    in_span = vector_span_comparer(comparer_params_eval, student_eval, utils)\n\n    expected_mag = np.linalg.norm(comparer_params_eval[0])\n    student_mag = np.linalg.norm(student_eval)\n    same_magnitude = utils.within_tolerance(expected_mag, student_mag)\n\n    return in_span and same_magnitude\n", "meta": {"hexsha": "76f5a0bff40aaa5604c2bc062cf81f4da4bb4e0f", "size": 18902, "ext": "py", "lang": "Python", "max_stars_repo_path": "mitxgraders/comparers/comparers.py", "max_stars_repo_name": "ChristopherChudzicki/mitx-grading-library", "max_stars_repo_head_hexsha": "1d9a7107f26b5e0ebe24deb552cf943779693e18", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "mitxgraders/comparers/comparers.py", "max_issues_repo_name": "ChristopherChudzicki/mitx-grading-library", "max_issues_repo_head_hexsha": "1d9a7107f26b5e0ebe24deb552cf943779693e18", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mitxgraders/comparers/comparers.py", "max_forks_repo_name": "ChristopherChudzicki/mitx-grading-library", "max_forks_repo_head_hexsha": "1d9a7107f26b5e0ebe24deb552cf943779693e18", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.3308411215, "max_line_length": 104, "alphanum_fraction": 0.6233202836, "include": true, "reason": "import numpy", "num_tokens": 4647, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.18242552825126704, "lm_q1q2_score": 0.09050017890342647}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Lab 2: Astronomical Imaging I \n# \n# *Gather round, for I shall tell a tale old as time. \n# Long, long ago, astronomers gazed at the heavens, and with naught but their eyes, recorded the positions of the stars they saw there. \n# Then, with the telescope, long, heavy contraptions which reached for the skies like an outstretched arm, (thanks, f/20 focal lengths)\n# they gazed through eyepieces in freezing domes, falling, on occasion, to their deaths from cages suspended at prime foci.* \n# \n# *Next came glass -- emulsion plates -- which upon extended exposure revealed upon their ghostly frames the splotches of stars and soon, galaxies and nebulae. \n# Many a grad student, of course, spent their nights twiddling thumbs over micrometer dials to keep these stars in place. Manual guiding... this story teller shudders to imagine it.\n# And yet, even then, with permanent record, no measure could be made that weren't 'tween the eyes of an observer, peering at the glass through magnifying eyepiece, assigning grades of brightness and, amazingly, pretty much nailing the spectral classification of stars by their absorption features*. \n# \n# *And after this painstaking work, came the earliest CCDs, fractured by detector failures, riddled with readout noise, consumed by cosmic ray hits, laid low by low quantum efficiencies.* \n# \n# *Now... we use Python.* \n# \n\n# <hr>\n# Astronomical images are one of the basic building blocks of astronomical research. While we now obtain data in myriad ways, from gravitational waves to neutrinos, from spectra to polarimetry, the basic tenant of astronomy (and it's most recongizable public impact) is the images we make of the sky. \n# \n# That is why the first science topic we'll be tackling is imaging. And along the way, we'll learn how `astropy` makes our lives *so* much easier when dealing with images, and how to use robust functions to perform the analyses one might want to carry out on images (after we're done admiring their beauty). \n# \n# # If the glove `FITS`\n# \n# Many of you are probably familiar with the `FITS` standard. It stands for `Flexible Image Transport System`, and for all intents and purposes, it acts as a container (much like a zip file). Within it, one can store several kinds of information: images (2d arrays of values), as the name implies, headers (dictionary like objects with metadata), and sometimes tabular data as well. A `FITS` file can contain any number of *extensions*, which just refer to \"slots\" where stuff is stored. Every \"slot\" has a `header` attribute and a `data` attribute. Thus, you could store a hundred astronomical images in 1 file, each with a different extension and a different header describing the image in that slot.  \n# \n# ```{tip}\n# Contextual clues are important when dealing with `FITS` files. Files that are explicitly single images almost always have the image stored in the 0th extension, while files that are explicitly table data tend to have the table stored in the 1st extension (with the 0th empty). \n# ```\n# \n# The `FITS` standard is pretty old, and may be retired soon, but almost all ground based telescopes still use it for their native image output, so it behooves us to know how to get image data out of `FITS` files. \n# \n# ## Problem 1: Loading a FITS file\n# \n# Write a function which takes as its argument a `string` filepath to a `FITS` file, and should have an optional argument to set the extension (default 0). It should then load the given extension of that `fits` file using a [context manager](https://docs.astropy.org/en/stable/io/fits/index.html#opening-a-fits-file), and return a tuple containing the header and data of that extension. \n# \n# The function should have documentation that describes the inputs and outputs. Documentation is **incredibly important** when writing code, both in-line and (# comments) and at the top of functions, methods, and classes. \n# \n# In this class, we'll be using [Sphinx-compatible](https://www.sphinx-doc.org/en/master/) documentation written in the [Numpy/Scipy style](https://numpydoc.readthedocs.io/en/latest/format.html). There are several reasons to do this. \n# \n# 1. It is a user-friendly and write-friendly, readable documentation format that is easy to add to your functions.\n# 2. It can be rendered by Sphinx, the most popular automatic documentation renderer. If you've ever read the online documentation pages for functions in, e.g., numpy and scipy, those pages were rendered automatically based on the docstrings of the functions in question. This is possible with tools like Sphinx, but the documentation must be formatted correctly for this to work. \n# \n# In the cell below, I've provided a dummy function which takes in any number of inputs (mininum 3) and chooses a random input to return. The formatting of the documentation is shown there (as well as in the link above). \n# \n# \n\n# In[5]:\n\n\nimport numpy as np \n\ndef random_return(a,b,c,*args):\n    '''\n    A function which requires three inputs which are floats, accepts any number of additional inputs (of any kind), and returns one randomly chosen input. \n    \n    Parameters\n    ----------\n    a: int\n        description of this integer input\n    b: int\n        description of this integer input\n    c: int\n        description of this integer input\n    *args: tuple\n        any additional arguments get stored here\n    \n    Returns\n    -------\n    choice \n        The randomly selected input (type not specified)\n    '''\n    full_input_list = [a,b,c] + list(args)\n    choice = np.random.choice(full_input_list)\n    return choice\n\n\n# In[11]:\n\n\nrandom_return(1,5,4,6,4,21,6)\n\n\n# When our function has been imported in some code, we can use the `help` command to see the documentation at any time:\n\n# In[9]:\n\n\nhelp(random_return)\n\n\n# You will also notice my use of `*args` in this function. This allows me to enter additional function arguments. Similar is `**kwargs`, which allows additional arguments tied to an input keyword. The former gets stored in a tuple, while the latter gets stored in a dictionary. We'll be using these a lot in class --- you can refresh or learn the basics in Section 2.8 of the chapter on functional programming [here](https://prappleizer.github.io/Tutorials/FunctionalProgramming/FunctionalProgramming_web.html).\n# \n# So as a brief overview of documentation, it contains\n# 1. A brief summary of the function \n# 2. The word Parameters with the next line having underlines of the same length\n# 3. arguments, which are followed by a colon and the data type(s). On the next line, indented, descriptions of the arguments\n# 4. The word Returns, with the same underline scheme\n# 5. The returned objects, labeled the same way as the input. \n# \n# Also above, we saw how to format when no data type is specified. There, additional inputs could've been *any* data type, so we can't be sure what the output will be. The main thing we didn't cover is optional arguments. Those are set like this:\n# ```\n# a: int, optional\n#     Description of the thing. (default 5)\n# ```\n# So we mark it as optional, and then give the default for it. \n# \n# With that, you're ready to write and document your code below. **All functions you write in this class should have documentation**. \n\n# In[10]:\n\n\nfrom astropy.io import fits \nimport os\n\n# your code\ndef load_fits(...):\n    '''\n\n    '''\n    pass\n\n            \n\n\n# ## Problem 2: Data I/O\n# ### Problem 2.1\n# Using the function you created above, read in the header and data of the file `antenna_Rband.fits` which came with the lab assignment. \n# ```{note}\n# While this may seem small, the fact that your read-in is now one line instead of ~5 does improve your efficiency! But only if you use your function enough times to overcome the initial time spent writing it... \n# We also have the flexibility to take our function and give it more features over time, which we will do in this class.\n# \n# ``` \n\n# ### Problem 2.2\n# Next, we need to plot the image data. There are several operations that we almost always perform when plotting astronomical data, as well as several user-preferences for how we \"by default\" plot images before we begin tweaking things. If you spend any time as an astronomer, you will plot quite literally *thousands* of images --- why set all these settings every time, when we can write a handy function to do it for us?\n# \n# Write a function which takes in as input arguments \n# - an image (2D array or masked array) \n# \n# as well as the following optional arguments (so set a default)\n# - figsize (default (15,13) )\n# - cmap (default 'gray_r')\n# - scale (default 0.5)\n# - \\*\\*kwargs (see [here](https://prappleizer.github.io/Tutorials/FunctionalProgramming/FunctionalProgramming_web.html))\n# \n# Inside the function, create figure and axes objects using `plt.subplots()`. When working in notebooks, it is often useful to set the `figsize` argument of subplots to a nice large-ish value, such as `(15,13)`, which will make the image fill most of the notebook. Since *your* function has set figsize as an argument, you can feed `figsize` directly into the `subplots` call, so that a user of the function can leave the default or set their own. \n# \n# Next, use `ax.imshow()` to actually plot the image. You'll want to save the output of this, e.g., `im = ax.imshow(...)`. In this plotting call, set `imshow`'s argument `origin='lower'`. We *always* want to do this when dealing with imaging, as we want (0,0) to be a coordinate. \n# ```{note}\n# By default, matplotlib uses a \"matrix-style\" plotting, where 0 of the y axis is in the *top* left corner, and 0 of the x axis is in the *bottom* left corner.\n# ```\n# Also within the call to `imshow()`, feed in the cmap from your function (i.e., `cmap=cmap`). The other critical `imshow()` arguments are `vmin` and `vmax`, which sets the saturation points (and thus the contrast) of the image. \n# \n# We haven't set `vmin` and `vmax` as arguments of our outer function, but because of `kwargs`, we can still create a default here that can be overriden from outside. \n# \n# As a default, within your function, calculate the mean and standard deviation of the image. Set some temporary variables with the quantities `mu - scale*sigma` and `mu + scale*sigma` (where here `mu` is the calculated mean and `sigma` is the calculated std dev, and `scale` was the optional input). Next, check the kwargs dictionary (which will exist in your function because we added the packing argument `**kwargs` to our function. IF `vmin` and `vmax` are in this dictionary, plug those into your imshow command. Otherwise, use the values determined by the calculation above. Bonus point for accomodating either no vmin/vmax entered, just vmin or vmax, or both (using the calculated values when things aren't provided). \n# \n# Your function should **return** the created `fig` and `ax` objects so the user can continue to tweak them.\n# \n# Run your function and test its outputs. Once you're satisfied it's working, use it to plot the provided data. Find either a vmin/vmax pair, or a choice of `scale` which makes the image look pretty!\n\n# In[ ]:\n\n\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n# Your code\ndef implot(...):\n    ''' \n    WRITE DOCSTRING HERE\n    '''\n    pass #replace with your code\n\n\n# In[42]:\n\n\n# I've included my output below for your comparison. Overwrite it with your own! \n\n\n# ### Problem 2.3\n# \n# Copy your function down, we're going to keep messing with it. \n# \n# So far, we've made it so that with a simple function call and, potentially, with just the input of an image array, we get out a nice plot with a scaling, colormap, and origin selection. In this section, we are going to allow (optionally) for a colorbar to be added to the figure. We're also going to add in the ability for the figure to be plotted in celestial coordinates (i.e., RA and DEC) instead of pixel units, if information about the image (via the world coordinate system, WCS) exists in the image header. \n# \n# ```{note}\n# Generally, WCS information is present in the headers of *published* images like the one here, but *not* present in raw data gathered at the telescope. This is because images need to undergo a process known as *plate solving* to determine both the direction (coordinates) toward the image, as well as the pixel scale (i.e., how many arcseconds per pixel in the image). \n# ```\n# \n# Add three new optional arguments to your function.\n# - colorbar = False\n# - header = None\n# - wcs = None\n# \n# Let's start with the colorbar. At the end of your plotting commands, check if `colorbar=True`, and if so, create a colorbar via `plt.colorbar()`, setting the `mappable` argument to whatever you saved the output of `ax.imshow()` into above. Also set the `ax` argument to be your ax; this will tell `matplotlib` to steal a bit of space from that axis to make room for the colorbar. \n# \n# \n# \n\n# In[46]:\n\n\n# Your code\n\n\n# ```{tip}\n# When I do this, the colorbar is matching the figure height, rather than the axis height. If that bugs you like it bugs me, check out [this solution](https://stackoverflow.com/a/33505522) from StackOverflow, which you can adapt within your function to make the cbar match the axis height.\n# ```\n# \n# In order to plot in RA and DEC coordinates, we need to first have an `astropy` `WCS` object associated with the image in question. You can import `WCS` from `astropy.wcs`. WCS objects are created from the headers of plate-solved fits files. In our function, we allow the user to input either a header or a WCS object directly. More on WCS can be found in the lecture notes, or [here](https://docs.astropy.org/en/stable/wcs/index.html).\n# \n# Within your function, check if a wcs is input -- if it is, we're good to go and can safely ignore `header` (even if it is provided). If instead only `header` is provided, use the `WCS()` function to create a new wcs object from that header. \n# ```{tip}\n# You'll want to do this at the very top of your function.\n# ```\n# \n# We now need to move our `fig, ax = ....` creation line into an if-statement. If we are using WCS \"stuff\", you'll need to set a `projection` for your plot that uses the wcs. This is accomplished as follows:\n# \n# ```\n# fig, ax = plt.subplots(...,subplot_kw={'projection':wcs}) \n# ```\n# where `wcs` is whatever you've named the output of `WCS(header)` or is the WCS input directly into the function. \n# \n# \n\n# In[4]:\n\n\nfrom astropy.wcs import WCS\n\n# your code\n\n\n# ```{warning}\n# In this case, we will get an error from our function that happens because of some distortion coefficient nonsense between astropy and drizzled HST images. Since it's not pertinent to our lab, I'm providing below a snippet of code you should use to fix your header before running `WCS(header)`. \n# ```\n\n# In[203]:\n\n\ndef strip_SIP(header):\n    A_prefixes = [i for i in header.keys() if i.startswith('A_')]\n    B_prefixes = [i for i in header.keys() if i.startswith('B_')]\n    for a,b in zip(A_prefixes,B_prefixes):\n        del header[a]\n        del header[b]\n    return header\n\n\n# If this worked correctly, when you add the header you read in from our image, you should now see the axes of your plot change from pixels to `pos.eq.ra` and `pos.eq.dec`. We're now looking at actual on-sky coordinates! Yay!\n# \n# ### Problem 2.4 \n# Within the if-blocks of your function that sets the `ax` to be a wcs projection, set the $x$ and $y$ labels to read \"Right Ascension \\[hms\\]\" and \"Declination \\[degrees\\]\" in fontsize 15.\n# \n# Lastly, to polish things off, use `ax.tick_params()` to set inward, larger ticks, and increase the axis tick label size to 15. \n# \n# ```{note}\n# You'll notice (especially with larger ticks) that the are not perpendicular to the axes spines. This is because this particular image has been rotated with respect to the standard celestial coordinate axes. This can be seen more clearly if you add the following to your function:\n# `ax.coords.grid(color='gray', alpha=0.5, linestyle='solid')`. Try doing that, adding an optional keyword to your function called 'grid' and enabling this command if it is set.\n# ```\n# \n# ```{tip}\n# To check if a condition is true (e.g, `if condition == True:`), you can just type `if condition:`\n# ```\n# \n# It's taken us some time, but this image could now be placed in a scientific publication. And, since we have a handy function for it, we can make images that look this nice on the fly with a short one line command, yet still have a lot of flexibility over many important inputs. And of course, the figure and axes objects are returned, so one could run this function and then continue tweaking the plot after the fact.\n# \n# ```{note}\n# As a final note, I want to draw your attention to the fact that once you use the `wcs` projection on some plot, it's no longer a normal ax object, it's a wcsax object. This makes changing certain elements of those axes a little more involved than for a standard one. I use [this page](https://docs.astropy.org/en/stable/visualization/wcsaxes/ticks_labels_grid.html) and the others linked there when doing so. \n# ```\n\n# ## Problem 3: Cutouts and Aperture Photometry\n\n# When working with astronomical images, like the one we've been using in this lab, it is often advantageous to be working with a cutout -- a chunk of the image centered on a certain coordinate, and of a certain size. For example, if there is an HII region or star cluster of interest in the above image, we may like to zoom in on it to examine it more closely. \n# \n# Now that we've switched over to using celestial coordinates instead of pixels as our projection frame, zooming in on a region is not as simple as slicing our array, e.g., `image[500:700,200:550]`. On the plus side, the framework we'll learn here is very robust, and will allow for all sorts of useful measurements. \n# \n# \n# To make a cutout, we'll need the `Cutout2D` module within `astropy`, which I'll import below. To provide the position of the cutout, we need to be able to feed in astronomical coordinates. For this, we'll use `SkyCoord`, a module in `astropy.coordinates`. Finally, we'll need to integrate the `units` module in `astropy` to successfully create coordinate objects.\n\n# In[100]:\n\n\nfrom astropy.nddata import Cutout2D\nfrom astropy.coordinates import SkyCoord\nimport astropy.units as u\n\n\n# Let's start with a `SkyCoord` object. There are several coordinate systems used in astronomy, e.g., Galactic coordinates ($b$, $l$), Equatorial ($RA$, $DEC$). The most common (especially in any extragalactic setting) is RA and DEC (as you can see in the image you've plotted already). \n# \n# The [documentation](https://docs.astropy.org/en/stable/api/astropy.coordinates.SkyCoord.html) for `SkyCoord` is solid, and worth reading. \n# \n# The general way we create these objects is, e.g.,\n\n# In[103]:\n\n\ncoord = SkyCoord('12:01:53.6 -18:53:11',unit=(u.hourangle,u.deg))\n\n\n# ```{tip}\n# You can input various types of strings and formattings for the coordinates, just be sure to specify the units as shown above. The documentation shows the various methods.\n# ```\n# \n# ### Problem 3.1\n# \n# In this case, the coordinates I set above are for NGC 4039, which is the smaller of the two galaxies in the image we're using. \n# \n# ```{note}\n# If at any point you're trying to make a coordinate object for a well known galaxy/object, try, e.g., `coord = SkyCoord.from_name('NGC 4038')`, and ususally that will work!\n# ```\n# \n# \n# In the cell below, use the coordinate we've created, plus a size (use 1x1 arcminutes), and the wcs object for our image, to create a `Cutout2D` object. \n\n# In[106]:\n\n\n#cutout = # your code here\n\n\n# Now, use your fancy new function to plot the new cutout. \n# ```{note}\n# Cutout objects contain the image and their own wcs, accessible via, e.g., `cutout.data` and `cutout.wcs`. \n# ```\n# \n\n# In[ ]:\n\n\n# plot it\n\n\n# ### Problem 3.2\n# \n# We're now going to do some aperture photometry. \n# ```{admonition} Definition\n# Aperture Photometry is the process of defining a region on an image (generally, but not always circular), and measuring the sum pixel value within that region. The region is known as an aperture, and the \"collapsing\" of the 2D spatial information about counts in each pixel into a single number is known as photometry.\n# ```\n# \n# Below, I provide a new coordinate, this time centered on the region between the two galaxies. Make a new cutout of that region (again, 1x1 arcmin), and plot it.\n\n# In[120]:\n\n\nnew_coord = SkyCoord('12:01:55.0 -18:52:45',unit=(u.hourangle,u.deg))\n\n\n# In[121]:\n\n\n# your code\n\n\n# In[5]:\n\n\n#plot it\n\n\n# In this region, there are a lot of blobby looking roughly circular sources --- Some of the larger ones are HII star forming regions, the smaller ones are likely stars. Later in this lab, we'll use multi-wavelength data to try to suss out what is what. \n# \n# Often, for calibration purposes, we'd need to create apertures around all those sources in the image. We definitely don't want to do that by hand! Instead, we're going to use the `sep` package. \n# \n# ```{note}\n# Simply `pip install sep` inside your `a330` environment terminal to get it installed, you should then be able to import it.\n# ```\n# \n# \n\n# In[123]:\n\n\nimport sep\n\n\n# There are three steps to performing aperture photometry with `sep`, which are detailed in [it's documentation](https://sep.readthedocs.io/en/v0.4.x/). \n# \n# - Estimate the background \n# - Find Sources \n# - Perform Aperture Photometry\n# \n# Using the instructions presented in the documentation linked, measure the background of the cutout image, and run the source extractor on it. Don't forget to subtract the background before running the extractor!\n# \n# To do this, write a function that takes as input the data (in this case, a `cutout.data` object and a threshold scale (to be multiplied by the `globalrms`, and performs these steps, returning the `objects` array. Don't forget to document it!\n# \n# ```{hint}\n# :class: dropdown\n# I used a threshold value of 2.0, and got ~100 objects. \n# ```\n# \n# ```{warning}\n# When I ran this, I got an error that my \"array was not C-contiguous.\" I found the solution to this issue in [this stackoverflow post](https://stackoverflow.com/a/26782930). Loosely, `sep` uses C-bindings to actually run the heavy lifting code in C rather than Python (it's faster). This means input arrays must be arranged in physical memory the way C is used to. This particular array was not, but it is easy to order it this way.\n# ```\n\n# In[173]:\n\n\n# Your code\n\ndef run_sep(...):\n    '''\n    DOCSTRING HERE \n    '''\n    pass\n\n\n# Run your function and store the output in a variable called `objects`. You should now have an object array containing many detected sources.\n\n# In[ ]:\n\n\n# run func\n\n\n# The positions of the determined sources are stored in the output structured array and can be indexed with, e.g., `objects['x']` and `objects['y']`. Replot your image of the cutout, but now circle the positions of all your detected sources. Do they line up with actual point sources in the image?\n# \n# ```{hint}\n# :class: dropdown\n# Try using ax.plot, setting your symbol to 'o', your color to 'None', your marker edge color (mec) to some color, and the marker size (ms) to some largeish value, for a quick way to circle objects.\n# ```\n\n# In[ ]:\n\n\n# Your code\n\n\n# In[167]:\n\n\n# Here's my image, for comparison \n\n\n# It looks like we've done a pretty adequate job finding the sources in this field -- there'a a few that got missed, and a few we might want to remove, but overall, this is pretty solid. \n# \n# We need to start working with these objects we've found. While `sep` can perform aperture photometry itself (reading the docs, you can see it is simple to feed in the objects and a pixel radius), we're going to be a bit more careful about things. To better visualize and work with this data, I'd like it to be a `pandas` `DataFrame`. We're going to be using those a lot in this course. Converting a `numpy` structured array to a dataframe is simple: I provide the code below. Run it, and then simply type `df` in a new cell to see a nicely formatted pandas table of our objects.\n\n# In[171]:\n\n\nimport pandas as pd\ndf = pd.DataFrame(objects)\n\n\n# In[ ]:\n\n\ndf #run this\n\n\n# With `sep` providing the first pass, we can cull a few objets from our sample that very clearly are not star forming regions. Using your DataFrame, plot the flux of each detected object using the `flux` column. You should have at least a few that are huge outliers, with dramatically more flux the rest. \n\n# In[6]:\n\n\n# plot\n\n\n# Write a function called `remove_outliers` that reads in a dataframe and a flux-min and flux-max. It should filter the dataframe to only include fluxes between the input values, and return the new dataframe. Then use this function on your data, choosing an appropriate cutoff.\n\n# In[182]:\n\n\n# Your Code \n\ndef remove_outliers(...):\n    '''\n    '''\n    pass\n\n\n# In[183]:\n\n\n# run the function\n\n\n# In[7]:\n\n\n# plot again\n\n\n# Re-plot the set of sources you have now, over the data.\n\n# In[8]:\n\n\n# plot\n\n\n# You should see that some of the circles which were over bright parts of the galaxy are no longer here. \n# ```{note}\n# You may find that there are some visible sources which, despite tinkering, don't get caught by `sep`. That's okay -- if we really wanted them, we could just go in and put down apertures by hand. Generally when performing a step like this in the field, we have a pre-determined set of points to use, because we have measured fluxes for them, and wish to flux calibrate our data. \n# ```\n# \n# ## Problem 4: Continuum Subtraction \n# \n# At this point, we have the tools necessary to make flux measurements in apertures (at least, via `sep` -- we will also learn how to do this with the `photutils` package). However, $R$ band photometry of HII regions is not exceedingly interesting. More interesting is the flux in $H\\alpha$, an emission line caused by Hydrogen recombination. This line (at 6563 Angstrom) is located *within* the $R$ band, and is imaged using a narrow filter compared ot $R$. \n# \n# The flux measured by an $H\\alpha$ filter contains both the flux from the emission line as well as the underlying continuum --- essentially, the starlight from the galaxy. If we can get a clean measure of the flux in $H\\alpha$ (sans this continuum), we can make a direct estimate of the star formation rate of the system. \n# \n# ### Problem 4.1\n# To do this, we need to access an $H\\alpha$ image, and then subtract off the continuum present (which we'll infer from our $R$ band image). Located in the lab directory is a file called `antenna_Haband.fits`. Use your fits loader function from above to read in this new image, create an equivalent sized and centered cutout to the $R$ band data, and plot it, with the same sources found in the $R$ band circled. \n\n# In[9]:\n\n\n# Your Code\n\n\n# There's a few interesting things to note right away here. Looking just north of the center of the image, there's now a large amount of flux in $H\\alpha$ coming from some blobs which do not appear in the $R$ band. This is likely due to the fact that by zero-ing in on the ionized gas, we can see the large envelopes of gas being lit up by the star formation in this region. \n# ```{note}\n# The active merger scenario between these two galaxies is triggering a lot of star formation.\n# ```\n# \n# ### Problem 4.2\n# \n# To get a better idea of how the $H\\alpha$ flux compares to the $R$ band distribution, use the `plt.contour()` tool to measure contours of $H\\alpha$, drawing them over the \n# $H\\alpha$ image and tweaking the levels until you think you are well tracing the distribution. Then, plot those contours over the $R$ band data instead. \n# \n# ```{hint}\n# It is often beneficial to use `np.logspace()` when defining contour levels, as it allows you to cover large dynamic range with fewer contours. You may also find it helpful to set your contour `alpha` to something < 1, to better see both the image underneath and the contours.\n# ```\n\n# In[10]:\n\n\n# Your Code\n\n\n# To help guide you, I've shown what I got for my plot below --- you need not emulate it exactly. The blue box shown in the image will be useful to you in the next part of the problem.\n\n# In[267]:\n\n\n# My solution\n\n\n# We can now see things a lot more clearly! It is obvious that the $H\\alpha$ contours trace some of the sources we were seeing in the $R$ band, but that the gas is more extended around these clusters of sources, as we might expect.\n# \n# ### Problem 4.3\n# We must now attempt a continuum subtraction of the data. We can't simply subtract the $R$ band from the $H\\alpha$ band, because the $R$ band filter is much wider, and thus for similar exposure times, collects many more photons than the narrower $H\\alpha$ filter. Ideally, one could use a set of foreground stars (which are pure continuum sources in both images) to measure fluxes in both, and find a scaling constant. Here, all of the sources we see in this image are most likely actually HII regions. This means if we use them to scale between our images, we will likely oversubtract true flux. \n# \n# Instead, what I'm going to do here (which may be slightly sketchy), is pick a \"blank\" region of continuum emission from the $R$ band which has no $H\\alpha$ contours, and assert that this patch must have the same flux in both images. In the picture above, I indicated a blue rectangular patch on the sky. This is what we'll be using to measure our continuum-to-narrowband ratio. \n# \n# To make this patch, we're going to use `SkyRectangularAperture`, from `photutils`. You can pip install `photutils` in your `a330` environment if you don't have it. Then do the following imports:\n\n# In[268]:\n\n\nfrom photutils.aperture import SkyRectangularAperture\nfrom photutils.aperture import aperture_photometry\n\n\n# As shown in [it's documentation](https://photutils.readthedocs.io/en/stable/api/photutils.aperture.SkyRectangularAperture.html), we need to feed in a `SkyCoord` position, as well as a width and a height. \n# I've provided the new coordinate to use below. \n# \n# Create a rectangle of your own, measuring $0.27''$ by $0.2''$. You can now use the `aperture_photometry()` function to measure the flux in your aperture, applied to a certain image. Using the [documentation](https://photutils.readthedocs.io/en/stable/api/photutils.aperture.aperture_photometry.html#photutils.aperture.aperture_photometry) as needed, find the flux in this box for both the $R$ band and $H\\alpha$ band data, and then determine the ratio between those values. Don't forget about the `wcs`!\n\n# In[11]:\n\n\npatch_cent = SkyCoord('12:01:53.7 -18:52:52',unit=(u.hourangle,u.deg))\n\n# Your code\n\n\n# We can now use this ratio to perform our subtraction. \n# \n# ### Problem 4.4\n# Now, fill in the function below, which should read in your rectangular patch, the $R$ band image, and the $H\\alpha$ image. Within the function, copy in the code that determines the ratio, and then use the ratio you found to scale your $R$ band image, then subtract it from the $H\\alpha$ image. The function should return this new image array.\n# \n# Plot up your continuum subtracted image using your `implot()` function, adding back in the apertures we found earlier and the contours we made from the full $H\\alpha$ image.\n\n# In[12]:\n\n\n# your code\ndef continuum_subtract(...):\n    '''\n    DOCSTRING HERE\n    '''\n    pass \n\n\n# What do you notice about the distribution of apertures with respect to the distribution of $H\\alpha$ gas? Is there a strong alignment of the $R$ band sources and the gas? What does this imply about most of the $R$ band sources?\n# \n# \n\n# *Answer here*\n\n# ### Problem 4.5 \n# \n# Lastly, let's load up the $B$ band image. As you probably know, the $B$ band traces bluer light, and thus will more preferentially see young, hot stars (whereas the $R$ band traces the main sequence and turn off stellar distribution). \n# \n# Load up the `antenna_Bband.fits` image, make a cutout, and plot it below. Use your `load_fits()` function and your `implot()` function. Make a new set of countours from your *continuum subtracted* $H\\alpha$ data, and overplot that onto the $B$ band data. What do you see?\n# \n\n# In[13]:\n\n\n# Your code\n\n\n# In my own image, there are some clusters of $B$-band flux that align well with the $H\\alpha$ contours, and some $B$ band sources out on their own. It is unsurprising that there is a correspondance between them; excess in $B$ light implies the prescence of UV radiation as well, from young O/B stars. It is this radiation responsible for ionizing the gas that is shining in $H\\alpha$, so the $H\\alpha$-emitting gas should be loosely clustered around sources bright in the $B$ band (the experiment would be even cleaner if we used, say, *GALEX* FUV data). \n\n# ### Bonus Question (up to 3 points)\n# \n# If you want to take your analysis farther, try measuring some fluxes off of your continuum subtracted $H\\alpha$ data, placing several manual apertures down over the regions of highest $H\\alpha$ concentration (which also align with $B$ band concentrations). \n# \n# The measures you get from this will be in counts on the detector. We need to convert these counts into flux units (e.g., erg s$^{-1}$ cm$^{-2}$). To do this, \n# - pull the 'PHOTFLAM' keyword from the header of your $H\\alpha$ data\n# - also pull the 'EXPTIME' value from the header. \n# \n# Start by taking your fluxes in counts, multiplying by the `PHOTFLAM` value, and dividing by the `EXPTIME` value. This puts you in erg s$^{-1}$ cm$^{-2}$ *per Angstrom*. Thus, what we have is technically a *flux density*. To convert to a true flux, we'll simply integrate over the bandpass... but for this example, let's assume a constant flux across the bandpass, which for the ACS 658N filter ($H\\alpha$), is 136.27 angstroms. \n# \n# Once you have fluxes, use the distance to NGC 4038/9 to determine the luminosity in erg/s of your collective set of sources, and then use the $SFR(H\\alpha)$ calibration of [Kennicut & Bell](https://iopscience.iop.org/article/10.1086/319025/fulltext/52481.text.html) to convert to an SFR. How does your answer compare to, e.g., \n# - The SFR of the Milky Way?\n# - The SFR of the Orion Nebula?\n# - The SFR of the Tarantula Nebula?\n", "meta": {"hexsha": "e60ad9cdb2a8f4c949b7f248f3cca0eb46b69567", "size": 34128, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/Lab2/Lab2.py", "max_stars_repo_name": "Astro-330/Astro-330.github.io", "max_stars_repo_head_hexsha": "e7ba5d1db0f369a110419e939d9ed2d29c9d7020", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-08-28T23:26:14.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T14:35:17.000Z", "max_issues_repo_path": "_build/jupyter_execute/Lab2/Lab2.py", "max_issues_repo_name": "mgebran/Astro-330.github.io", "max_issues_repo_head_hexsha": "e7ba5d1db0f369a110419e939d9ed2d29c9d7020", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/Lab2/Lab2.py", "max_forks_repo_name": "mgebran/Astro-330.github.io", "max_forks_repo_head_hexsha": "e7ba5d1db0f369a110419e939d9ed2d29c9d7020", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-12-18T00:53:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T14:53:12.000Z", "avg_line_length": 54.3439490446, "max_line_length": 725, "alphanum_fraction": 0.7333567745, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 8541, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49609382947091946, "lm_q2_score": 0.18242552602881165, "lm_q1q2_score": 0.09050017780088007}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# \n# #  Tutorial 1: \"What\" models\n# __Content creators:__ Matt Laporte, Byron Galbraith, Konrad Kording\n# \n# __Content reviewers:__ Dalin Guo, Aishwarya Balwani, Madineh Sarvestani, Maryam Vaziri-Pashkam, Michael Waskom\n# \n# We would like to acknowledge [Steinmetz _et al._ (2019)](https://www.nature.com/articles/s41586-019-1787-x) for sharing their data, a subset of which is used here.\n# \n\n# ___\n# # Tutorial Objectives\n# This is tutorial 1 of a 3-part series on different flavors of models used to understand neural data. In this tutorial we will explore 'What' models, used to describe the data. To understand what our data looks like, we will visualize it in different ways. Then we will compare it to simple mathematical models. Specifically, we will:\n# \n# - Load a dataset with spiking activity from hundreds of neurons and understand how it is organized\n# - Make plots to visualize characteristics of the spiking activity across the population\n# - Compute the distribution of \"inter-spike intervals\" (ISIs) for a single neuron\n# - Consider several formal models of this distribution's shape and fit them to the data \"by hand\"\n\n# In[ ]:\n\n\n#@title Video 1: \"What\" Models\nfrom IPython.display import YouTubeVideo\nvideo = YouTubeVideo(id='KgqR_jbjMQg', width=854, height=480, fs=1)\nprint(\"Video available at https://youtube.com/watch?v=\" + video.id)\nvideo\n\n\n# # Setup\n# \n# \n\n# Python requires you to explictly \"import\" libraries before their functions are available to use. We will always specify our imports at the beginning of each notebook or script.\n\n# In[ ]:\n\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\n# Tutorial notebooks typically begin with several set-up steps that are hidden from view by default.\n# \n# **Important:** Even though the code is hidden, you still need to run it so that the rest of the notebook can work properly. Step through each cell, either by pressing the play button in the upper-left-hand corner or with a keyboard shortcut (`Cmd-Return` on a Mac, `Ctrl-Enter` otherwise). A number will appear inside the brackets (e.g. `[3]`) to tell you that the cell was executed and what order that happened in.\n# \n# If you are curious to see what is going on inside each cell, you can double click to expand. Once expanded, double-click the white space to the right of the editor to collapse again.\n\n# In[ ]:\n\n\n#@title Figure Settings\nimport ipywidgets as widgets #interactive display\n\nget_ipython().run_line_magic('matplotlib', 'inline')\nget_ipython().run_line_magic('config', \"InlineBackend.figure_format = 'retina'\")\nplt.style.use(\"https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/nma.mplstyle\")\n\n\n# In[ ]:\n\n\n#@title Helper functions\n\n#@markdown Most of the tutorials make use of helper functions\n#@markdown to simplify the code that you need to write. They are defined here.\n\n# Please don't edit these, or worry about understanding them now!\n\ndef restrict_spike_times(spike_times, interval):\n  \"\"\"Given a spike_time dataset, restrict to spikes within given interval.\n\n  Args:\n    spike_times (sequence of np.ndarray): List or array of arrays,\n      each inner array has spike times for a single neuron.\n    interval (tuple): Min, max time values; keep min <= t < max.\n\n  Returns:\n    np.ndarray: like `spike_times`, but only within `interval`\n  \"\"\"\n  interval_spike_times = []\n  for spikes in spike_times:\n    interval_mask = (spikes >= interval[0]) & (spikes < interval[1])\n    interval_spike_times.append(spikes[interval_mask])\n  return np.array(interval_spike_times, object)\n\n\n# In[ ]:\n\n\n#@title Data retrieval\n#@markdown This cell downloads the example dataset that we will use in this tutorial.\nimport io\nimport requests\nr = requests.get('https://osf.io/sy5xt/download')\nif r.status_code != 200:\n  print('Failed to download data')\nelse:\n  spike_times = np.load(io.BytesIO(r.content), allow_pickle=True)['spike_times']\n\n\n# ---\n# \n# # Section 1: Exploring the Steinmetz dataset\n# \n# In this tutorial we will explore the structure of a neuroscience dataset. \n# \n# We consider a subset of data from a study of [Steinmetz _et al._ (2019)](https://www.nature.com/articles/s41586-019-1787-x). In this study, Neuropixels probes were implanted in the brains of mice. Electrical potentials were measured by hundreds of electrodes along the length of each probe. Each electrode's measurements captured local variations in the electric field due to nearby spiking neurons. A spike sorting algorithm was used to infer spike times and cluster spikes according to common origin: a single cluster of sorted spikes is causally attributed to a single neuron.\n# \n# In particular, a single recording session of spike times and neuron assignments was loaded and assigned to `spike_times` in the preceding setup. \n# \n# Typically a dataset comes with some information about its structure. However, this information may be incomplete. You might also apply some transformations or \"pre-processing\" to create a working representation of the data of interest, which might go partly undocumented depending on the circumstances. In any case it is important to be able to use the available tools to investigate unfamiliar aspects of a data structure. \n# \n# Let's see what our data looks like...\n\n# ## Section 1.1: Warming up with `spike_times`\n\n# What is the Python type of our variable?\n\n# In[ ]:\n\n\ntype(spike_times)\n\n\n# You should see `numpy.ndarray`, which means that it's a normal NumPy array.\n# \n# If you see an error message, it probably means that you did not execute the set-up cells at the top of the notebook. So go ahead and make sure to do that.\n# \n# Once everything is running properly, we can ask the next question about the dataset: what's its shape?\n\n# In[ ]:\n\n\nspike_times.shape\n\n\n# There are 734 entries in one dimension, and no other dimensions. What is the Python type of the first entry, and what is *its* shape?\n\n# In[ ]:\n\n\nidx = 0\nprint(\n  type(spike_times[idx]),\n  spike_times[idx].shape,\n  sep=\"\\n\",\n)\n\n\n# It's also a NumPy array with a 1D shape! Why didn't this show up as a second dimension in the shape of `spike_times`? That is, why not `spike_times.shape == (734, 826)`?\n# \n# To investigate, let's check another entry.\n\n# In[ ]:\n\n\nidx = 321\nprint(\n  type(spike_times[idx]),\n  spike_times[idx].shape,\n  sep=\"\\n\",\n)\n\n\n# It's also a 1D NumPy array, but it has a different shape. Checking the NumPy types of the values in these arrays, and their first few elements, we see they are composed of floating point numbers (not another level of `np.ndarray`):\n\n# In[ ]:\n\n\ni_neurons = [0, 321]\ni_print = slice(0, 5)\n\nfor i in i_neurons:\n  print(\n    \"Neuron {}:\".format(i),\n    spike_times[i].dtype,\n    spike_times[i][i_print],\n    \"\\n\",\n    sep=\"\\n\"\n  )\n\n\n# Note that this time we've checked the NumPy `dtype` rather than the Python variable type. These two arrays contain floating point numbers (\"floats\") with 32 bits of precision.\n# \n# The basic picture is coming together:\n# - `spike_times` is 1D, its entries are NumPy arrays, and its length is the number of neurons (734): by indexing it, we select a subset of neurons. \n# - An array in `spike_times` is also 1D and corresponds to a single neuron; its entries are floating point numbers, and its length is the number of spikes attributed to that neuron. By indexing it, we select a subset of spike times for that neuron. \n# \n# Visually, you can think of the data structure as looking something like this:\n# \n# ```\n# | . . . . . |\n# | . . . . . . . . |\n# | . . . |\n# | . . . . . . . |\n# ```\n# \n# Before moving on, we'll calculate and store the number of neurons in the dataset and the number of spikes per neuron:\n\n# In[ ]:\n\n\nn_neurons = len(spike_times)\ntotal_spikes_per_neuron = [len(spike_times_i) for spike_times_i in spike_times]\n\nprint(f\"Number of neurons: {n_neurons}\")\nprint(f\"Number of spikes for first five neurons: {total_spikes_per_neuron[:5]}\")\n\n\n# In[ ]:\n\n\n#@title Video 2: Exploring the dataset\nfrom IPython.display import YouTubeVideo\nvideo = YouTubeVideo(id='oHwYWUI_o1U', width=854, height=480, fs=1)\nprint(\"Video available at https://youtube.com/watch?v=\" + video.id)\nvideo\n\n\n# ## Section 1.2: Getting warmer: counting and plotting total spike counts\n# \n# As we've seen, the number of spikes over the entire recording is variable between neurons. More generally, some neurons tend to spike more than others in a given period. Lets explore what the distribution of spiking looks like across all the neurons in the dataset.\n\n# Are most neurons \"loud\" or \"quiet\", compared to the average? To see, we'll define bins of constant width in terms of total spikes and count the neurons that fall in each bin. This is known as a \"histogram\".\n# \n# You can plot a histogram with the matplotlib function `plt.hist`. If you just need to compute it, you can use the numpy function `np.histogram` instead.\n\n# In[ ]:\n\n\nplt.hist(total_spikes_per_neuron, bins=50, histtype=\"stepfilled\")\nplt.xlabel(\"Total spikes per neuron\")\nplt.ylabel(\"Number of neurons\");\n\n\n# Let's see what percentage of neurons have a below-average spike count:\n\n# In[ ]:\n\n\nmean_spike_count = np.mean(total_spikes_per_neuron)\nfrac_below_mean = (total_spikes_per_neuron < mean_spike_count).mean()\nprint(f\"{frac_below_mean:2.1%} of neurons are below the mean\")\n\n\n# We can also see this by adding the average spike count to the histogram plot:\n\n# In[ ]:\n\n\nplt.hist(total_spikes_per_neuron, bins=50, histtype=\"stepfilled\")\nplt.xlabel(\"Total spikes per neuron\")\nplt.ylabel(\"Number of neurons\")\nplt.axvline(mean_spike_count, color=\"orange\", label=\"Mean neuron\")\nplt.legend();\n\n\n# This shows that the majority of neurons are relatively \"quiet\" compared to the mean, while a small number of neurons are exceptionally \"loud\": they must have spiked more often to reach a large count.\n# \n# ### Exercise 1: Comparing mean and median neurons\n# \n# If the mean neuron is more active than 68% of the population, what does that imply about the relationship between the mean neuron and the median neuron?\n# \n# *Exercise objective:* Reproduce the plot above, but add the median neuron.\n# \n\n# In[ ]:\n\n\n# To complete the exercise, fill in the missing parts (...) and uncomment the code\n\nmedian_spike_count = ...  # Hint: Try the function np.median\n\n# plt.hist(..., bins=50, histtype=\"stepfilled\")\n# plt.axvline(..., color=\"limegreen\", label=\"Median neuron\")\n# plt.axvline(mean_spike_count, color=\"orange\", label=\"Mean neuron\")\n# plt.xlabel(\"Total spikes per neuron\")\n# plt.ylabel(\"Number of neurons\")\n# plt.legend()\n\n\n# [*Click for solution*](https://github.com/NeuromatchAcademy/course-content/tree/master//tutorials/W1D1_ModelTypes/solutions/W1D1_Tutorial1_Solution_b3411d5d.py)\n# \n# *Example output:*\n# \n# <img alt='Solution hint' align='left' width=558 height=413 src=https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/tutorials/W1D1_ModelTypes/static/W1D1_Tutorial1_Solution_b3411d5d_0.png>\n# \n# \n\n# \n# *Bonus:* The median is the 50th percentile. What about other percentiles? Can you show the interquartile range on the histogram?\n\n# ---\n# \n# # Section 2: Visualizing neuronal spiking activity\n\n# ## Section 2.1: Getting a subset of the data\n# \n# Now we'll visualize trains of spikes. Because the recordings are long, we will first define a short time interval and restrict the visualization to only the spikes in this interval. We defined a utility function, `restrict_spike_times`, to do this for you. If you call `help()` on the function, it will tell you a little bit about itself:\n\n# In[ ]:\n\n\nhelp(restrict_spike_times)\n\n\n# In[ ]:\n\n\nt_interval = (5, 15)  # units are seconds after start of recording\ninterval_spike_times = restrict_spike_times(spike_times, t_interval)\n\n\n# Is this a representative interval? What fraction of the total spikes fall in this interval?\n\n# In[ ]:\n\n\noriginal_counts = sum([len(spikes) for spikes in spike_times])\ninterval_counts = sum([len(spikes) for spikes in interval_spike_times])\nfrac_interval_spikes = interval_counts / original_counts\nprint(f\"{frac_interval_spikes:.2%} of the total spikes are in the interval\")\n\n\n# How does this compare to the ratio between the interval duration and the experiment duration? (What fraction of the total time is in this interval?)\n# \n# We can approximate the experiment duration by taking the minimum and maximum spike time in the whole dataset. To do that, we \"concatenate\" all of the neurons into one array and then use `np.ptp` (\"peak-to-peak\") to get the difference between the maximum and minimum value:\n\n# In[ ]:\n\n\nspike_times_flat = np.concatenate(spike_times)\nexperiment_duration = np.ptp(spike_times_flat)\ninterval_duration = t_interval[1] - t_interval[0]\n\nfrac_interval_time = interval_duration / experiment_duration\nprint(f\"{frac_interval_time:.2%} of the total time is in the interval\")\n\n\n# These two values—the fraction of total spikes and the fraction of total time—are similar. This suggests the average spike rate of the neuronal population is not very different in this interval compared to the entire recording.\n# \n# ## Section 2.2: Plotting spike trains and rasters\n# \n# Now that we have a representative subset, we're ready to plot the spikes, using the matplotlib `plt.eventplot` function. Let's look at a single neuron first:\n\n# In[ ]:\n\n\nneuron_idx = 1\nplt.eventplot(interval_spike_times[neuron_idx], color=\".2\")\nplt.xlabel(\"Time (s)\")\nplt.yticks([]);\n\n\n# We can also plot multiple neurons. Here are three:\n\n# In[ ]:\n\n\nneuron_idx = [1, 11, 51]\nplt.eventplot(interval_spike_times[neuron_idx], color=\".2\")\nplt.xlabel(\"Time (s)\")\nplt.yticks([]);\n\n\n# This makes a \"raster\" plot, where the spikes from each neuron appear in a different row.\n# \n# Plotting a large number of neurons can give you a sense for the characteristics in the population. Let's show every 5th neuron that was recorded:\n\n# In[ ]:\n\n\nneuron_idx = np.arange(0, len(spike_times), 5)\nplt.eventplot(interval_spike_times[neuron_idx], color=\".2\")\nplt.xlabel(\"Time (s)\")\nplt.yticks([]);\n\n\n# *Question*: How does the information in this plot relate to the histogram of total spike counts that you saw above?\n\n# In[ ]:\n\n\n#@title Video 3: Visualizing activity\nfrom IPython.display import YouTubeVideo\nvideo = YouTubeVideo(id='QGA5FCW7kkA', width=854, height=480, fs=1)\nprint(\"Video available at https://youtube.com/watch?v=\" + video.id)\nvideo\n\n\n# ---\n# \n# # Section 3: Inter-spike intervals and their distributions\n\n# Given the ordered arrays of spike times for each neuron in `spike_times`, which we've just visualized, what can we ask next? \n# \n# Scientific questions are informed by existing models. So, what knowledge do we already have that can inform questions about this data?\n# \n# We know that there are physical constraints on neuron spiking. Spiking costs energy, which the neuron's cellular machinery can only obtain at a finite rate. Therefore neurons should have a refractory period: they can only fire as quickly as their metabolic processes can support, and there is a minimum delay between consecutive spikes of the same neuron.\n# \n# More generally, we can ask \"how long does a neuron wait to spike again?\" or \"what is the longest a neuron will wait?\" Can we transform spike times into something else, to address questions like these more directly?\n# \n# We can consider the inter-spike times (or interspike intervals: ISIs). These are simply the time differences between consecutive spikes of the same neuron.\n# \n# ### Exercise 2: Plot the distribution of ISIs for a single neuron\n# \n# *Exercise objective:* make a histogram, like we did for spike counts, to show the distribution of ISIs for one of the neurons in the dataset.\n# \n# Do this in three steps:\n# \n# 1. Extract the spike times for one of the neurons\n# 2. Compute the ISIs (the amount of time between spikes, or equivalently, the difference between adjacent spike times)\n# 3. Plot a histogram with the array of individual ISIs\n\n# In[ ]:\n\n\ndef compute_single_neuron_isis(spike_times, neuron_idx):\n  \"\"\"Compute a vector of ISIs for a single neuron given spike times.\n\n  Args:\n    spike_times (list of 1D arrays): Spike time dataset, with the first\n      dimension corresponding to different neurons.\n    neuron_idx (int): Index of the unit to compute ISIs for.\n\n  Returns:\n    isis (1D array): Duration of time between each spike from one neuron.\n  \"\"\"\n  #############################################################################\n  # Students: Fill in missing code (...) and comment or remove the next line\n  raise NotImplementedError(\"Exercise: compute single neuron ISIs\")\n  #############################################################################\n\n  # Extract the spike times for the specified neuron\n  single_neuron_spikes = ...\n\n  # Compute the ISIs for this set of spikes\n  # Hint: the function np.diff computes discrete differences along an array\n  isis = ...\n\n  return isis\n\n# Uncomment the following lines when you are ready to test your function\n# single_neuron_isis = compute_single_neuron_isis(spike_times, neuron_idx=283)\n# plt.hist(single_neuron_isis, bins=50, histtype=\"stepfilled\")\n# plt.axvline(single_neuron_isis.mean(), color=\"orange\", label=\"Mean ISI\")\n# plt.xlabel(\"ISI duration (s)\")\n# plt.ylabel(\"Number of spikes\")\n# plt.legend()\n\n\n# [*Click for solution*](https://github.com/NeuromatchAcademy/course-content/tree/master//tutorials/W1D1_ModelTypes/solutions/W1D1_Tutorial1_Solution_4792dbfa.py)\n# \n# *Example output:*\n# \n# <img alt='Solution hint' align='left' width=558 height=414 src=https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/tutorials/W1D1_ModelTypes/static/W1D1_Tutorial1_Solution_4792dbfa_0.png>\n# \n# \n\n# ---\n# \n# In general, the shorter ISIs are predominant, with counts decreasing rapidly (and smoothly, more or less) with increasing ISI. However, counts also rapidly decrease to zero with _decreasing_ ISI, below the maximum of the distribution (8-11 ms). The absence of these very low ISIs agrees with the refractory period hypothesis: the neuron cannot fire quickly enough to populate this region of the ISI distribution.\n# \n# Check the distributions of some other neurons. To resolve various features of the distributions, you might need to play with the value of `n_bins`. Using too few bins might smooth over interesting details, but if you use too many bins, the random variability will start to dominate.\n# \n# You might also want to restrict the range to see the shape of the distribution when focusing on relatively short or long ISIs. *Hint:* `plt.hist` takes a `range` argument \n\n# ---\n# \n# # Section 4: What is the functional form of an ISI distribution?\n\n# In[ ]:\n\n\n#@title Video 4: ISI distribution\nfrom IPython.display import YouTubeVideo\nvideo = YouTubeVideo(id='DHhM80MOTe8', width=854, height=480, fs=1)\nprint(\"Video available at https://youtube.com/watch?v=\" + video.id)\nvideo\n\n\n# The ISI histograms seem to follow continuous, monotonically decreasing functions above their maxima. The function is clearly non-linear. Could it belong to a single family of functions?\n# \n# To motivate the idea of using a mathematical function to explain physiological phenomena, let's define a few different function forms that we might expect the relationship to follow: exponential, inverse, and linear.\n\n# In[ ]:\n\n\ndef exponential(xs, scale, rate, x0):\n  \"\"\"A simple parametrized exponential function, applied element-wise.\n\n  Args:\n    xs (np.ndarray or float): Input(s) to the function.\n    scale (float): Linear scaling factor.\n    rate (float): Exponential growth (positive) or decay (negative) rate.\n    x0 (float): Horizontal offset.\n\n  \"\"\"\n  ys = scale * np.exp(rate * (xs - x0))\n  return ys\n\ndef inverse(xs, scale, x0):\n  \"\"\"A simple parametrized inverse function (`1/x`), applied element-wise.\n\n  Args:\n    xs (np.ndarray or float): Input(s) to the function.\n    scale (float): Linear scaling factor.\n    x0 (float): Horizontal offset.\n\n  \"\"\"\n  ys = scale / (xs - x0)\n  return ys\n\ndef linear(xs, slope, y0):\n  \"\"\"A simple linear function, applied element-wise.\n\n  Args:\n    xs (np.ndarray or float): Input(s) to the function.\n    slope (float): Slope of the line.\n    y0 (float): y-intercept of the line.\n\n  \"\"\"\n  ys = slope * xs + y0\n  return ys\n\n\n# ### Interactive Demo: ISI functions explorer\n# \n# Here is an interactive demo where you can vary the parameters of these functions and see how well the resulting outputs correspond to the data. Adjust the parameters by moving the sliders and see how close you can get the lines to follow the falling curve of the histogram. This will give you a taste of what you're trying to do when you *fit a model* to data.\n# \n# \"Interactive demo\" cells have hidden code that defines an interface where you can play with the parameters of some function using sliders. You don't need to worry about how the code works – but you do need to **run the cell** to enable the sliders.\n# \n\n# In[ ]:\n\n\n#@title\n\n#@markdown Be sure to run this cell to enable the demo\n# Don't worry about understanding this code! It's to setup an interactive plot.\nsingle_neuron_idx = 283\nsingle_neuron_spikes = spike_times[single_neuron_idx]\nsingle_neuron_isis = np.diff(single_neuron_spikes)\n\ncounts, edges = np.histogram(\n  single_neuron_isis,\n  bins=50,\n  range=(0, single_neuron_isis.max())\n)\n\nfunctions = dict(\n  exponential=exponential,\n  inverse=inverse,\n  linear=linear,\n)\n\ncolors = dict(\n  exponential=\"C1\",\n  inverse=\"C2\",\n  linear=\"C4\",\n)\n\n@widgets.interact(\n  exp_scale=widgets.FloatSlider(1000, min=0, max=20000, step=250),\n  exp_rate=widgets.FloatSlider(-10, min=-200, max=50, step=1),\n  exp_x0=widgets.FloatSlider(0.1, min=-0.5, max=0.5, step=0.005),\n  inv_scale=widgets.FloatSlider(1000, min=0, max=3e2, step=10),\n  inv_x0=widgets.FloatSlider(0, min=-0.2, max=0.2, step=0.01),\n  lin_slope=widgets.FloatSlider(-1e5, min=-6e5, max=1e5, step=10000),\n  lin_y0=widgets.FloatSlider(10000, min=0, max=4e4, step=1000),\n)\ndef fit_plot(\n  exp_scale=1000, exp_rate=-10, exp_x0=0.1,\n  inv_scale=1000, inv_x0=0,\n  lin_slope=-1e5, lin_y0=2000,\n):\n  \"\"\"Helper function for plotting function fits with interactive sliders.\"\"\"\n  func_params = dict(\n    exponential=(exp_scale, exp_rate, exp_x0),\n    inverse=(inv_scale, inv_x0),\n    linear=(lin_slope, lin_y0),\n  )\n  f, ax = plt.subplots()\n  ax.fill_between(edges[:-1], counts, step=\"post\", alpha=.5)\n  xs = np.linspace(1e-10, edges.max())\n  for name, function in functions.items():\n    ys = function(xs, *func_params[name])\n    ax.plot(xs, ys, lw=3, color=colors[name], label=name);\n  ax.set(\n      xlim=(edges.min(), edges.max()),\n      ylim=(0, counts.max() * 1.1),\n      xlabel=\"ISI (s)\",\n      ylabel=\"Number of spikes\",\n  )\n  ax.legend()\n\n\n# In[ ]:\n\n\n#@title Video 5: Fitting models by hand\nfrom IPython.display import YouTubeVideo\nvideo = YouTubeVideo(id='uW2HDk_4-wk', width=854, height=480, fs=1)\nprint(\"Video available at https://youtube.com/watch?v=\" + video.id)\nvideo\n\n\n# # Summary\n# \n# In this tutorial, we loaded some neural data and poked at it to understand how the dataset is organized. Then we made some basic plots to visualize (1) the average level of activity across the population and (2) the distribution of ISIs for an individual neuron. In the very last bit, we started to think about using mathematical formalisms to understand or explain some physiological phenomenon. All of this only allowed us to understand \"What\" the data looks like.\n# \n# This is the first step towards developing models that can tell us something about the brain. That's what we'll focus on in the next two tutorials.\n", "meta": {"hexsha": "724dcc6239721bf5d0a4f1861585733cf8ccfc19", "size": 23521, "ext": "py", "lang": "Python", "max_stars_repo_path": "prototype/_build/jupyter_execute/W1D1_Tutorial1.py", "max_stars_repo_name": "ebatty/prototype", "max_stars_repo_head_hexsha": "9789b6109d93d6bb166f8aea81364d15f5315455", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "prototype/_build/jupyter_execute/W1D1_Tutorial1.py", "max_issues_repo_name": "ebatty/prototype", "max_issues_repo_head_hexsha": "9789b6109d93d6bb166f8aea81364d15f5315455", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "prototype/_build/jupyter_execute/W1D1_Tutorial1.py", "max_forks_repo_name": "ebatty/prototype", "max_forks_repo_head_hexsha": "9789b6109d93d6bb166f8aea81364d15f5315455", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.1834415584, "max_line_length": 581, "alphanum_fraction": 0.7365333107, "include": true, "reason": "import numpy", "num_tokens": 5869, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41489884579676883, "lm_q2_score": 0.21733752611649484, "lm_q1q2_score": 0.09017308873405881}}
{"text": "# python src/chapter7/chapter7note.py\n# python3 src/chapter7/chapter7note.py\n'''\nClass Chapter7_1\n\nClass Chapter7_2\n\nClass Chapter7_3\n\nClass Chapter7_4\n'''\n\nfrom __future__ import division, absolute_import, print_function\n\nimport sys as _sys\nimport math as _math\nimport random as _random\nimport time as _time\nfrom random import randint as _randint\nfrom copy import copy as _copy, deepcopy as _deepcopy\nfrom numpy import arange as _arange\n\nif __name__ == '__main__':\n    import quicksort\n    import stooge\nelse:\n    from . import quicksort\n    from . import stooge\n\nclass Chapter7_1:\n    def note(self):\n        '''\n        Summary\n        ====\n        Print chapter7.1 note\n\n        Example\n        ====\n        >>> Chapter7_1().note()\n        '''\n        print('chapter7.1 note as follow')\n        print('第7章 快速排序')\n        print('快速排序是一种排序算法，对包含n个数的输入数组进行排序，最坏情况的运行时间为Θ(n^2)')\n        print('虽然这个最坏情况运行时间比较差，但是快速排序通常是用于排序最佳的实用选择，这是因为其平均性能相当好')\n        print('快速排序期望的运行时间为Θ(nlgn),且Θ(nlgn)记号中隐含的常数因子很小')\n        print('快速排序能够进行就地排序，在虚存坏境中也能很好地工作')\n        print('7.1 快速排序的描述')\n        print('像合并排序一样，快速排序也是基于分治模式的')\n        print(' 1.分解:数组A[p..r]被划分成两个(可能为空的)子数组A[p..q-1]和A[q+1..r]')\n        print('  使得A[p..q-1]中的每个元素都小于等于A(q),而且，小于等于A[q+1..r]')\n        print('  下标q也在这个划分过程中进行计算')\n        print(' 2.解决:通过递归调用快速排序，对子数组A[p..q-1]和A[q+1..r]排序')\n        print(' 3.合并:因为这两个子数组是就地排序的(不开辟新的数组),将他们合并不需要任何操作，整个数组A[p..r]已经排好序')\n        print('子数组快速排序伪代码')\n        print('QUICKSORT(A,p,r)')\n        print(' 1. if q < r')\n        print(' 2.   q <- PARTITION(A,p,r)')\n        print(' 3.       QUICKSORT(A,p,q-1)')\n        print(' 3.       QUICKSORT(A,q+1,r)')\n        print('排序完整的数组A，调用QUICKSORT(A,0,len(A))即可')\n        print('快速排序算法的关键是PARTITION过程，它对子数组A[q..r]进行就地重排')\n        print('PARTITION(A,p,r)')\n        print(' 1. x <- A[r]')\n        print(' 2. i <- p-1')\n        print(' 3. for j <- p to r-1')\n        print(' 4.  if A[j] <= x')\n        print(' 5.      i <- i+1')\n        print(' 6.      exchange A[i] <-> A[j]')\n        print(' 7. exchange A[i+1] <-> A[r]')\n        print(' 8. return i + 1')\n        A = [8, 9, 6, 7, 4, 5, 2, 3, 1]\n        print('数组A', _deepcopy(A), '的快速排序过程为:', \n            quicksort.quicksort(A))\n        A = [13, 19, 9, 5, 12, 8, 7, 4, 11, 2, 6, 21]\n        print('练习7.1-1 数组A', _deepcopy(A), \n            '的一步partition过程得到middle索引为：', \n            quicksort.partition(A, 0, len(A) - 1))\n        A = [11, 11, 11, 11, 11]\n        print('练习7.1-2 数组A', _deepcopy(A), \n            '的一步partition过程得到middle索引为：', \n            quicksort.partition(A, 0, len(A) - 1))\n        print('练习7.1-3 就一个长度为n的for循环，且一定会执行，所以时间复杂度为Θ(n)，然后用确界的夹逼定义证明')\n        print('练习7.1-4 不等号方向改变即可')\n        # python src/chapter7/chapter7note.py\n        # python3 src/chapter7/chapter7note.py\n\nclass Chapter7_2:\n    def note(self):\n        '''\n        Summary\n        ====\n        Print chapter7.2 note\n\n        Example\n        ====\n        >>> Chapter7_2().note()\n        '''\n        print('chapter7.2 note as follow')\n        print('7.2 快速排序的性能')\n        print('快速排序的运行时间与划分是否对称有关，而后者由与选择了哪个元素来进行划分有关')\n        print('如果划分是对称的，那么快速排序算法从渐进上与合并算法一样快，否则就和插入排序一样慢')\n        print('快速情况的最坏情况划分行为发生在划分过程产生的两个区域分别包含n-1个元素和1个0元素的时候')\n        print('假设每次划分都出现了这种不对称划分，划分的时间代价为Θ(n),故算法的运行时间可以递归地写为')\n        print('T(n)=T(n-1)+T(0)+Θ(n),递归式的解为T(n)=Θ(n^2)')\n        print('快速排序的最坏情况并不比插入排序的最坏情况更好')\n        print('另外，当一个已经排序好时，快速排序运行时间Θ(n^2)，插入排序运行时间Θ(n)')\n        print('快速排序最佳情况是是其中一个字问题的大小为[n/2],另一个问题的大小为[n/2]-1')\n        print('在这种情况下，快速排序的运行时间要快的多，T(n)<=T(n/2)+Θ(n)')\n        print('根据主定理，以上递归式的解为O(nlgn)')\n        print('平衡的划分')\n        print('快速排序的平均运行时间与其最佳运行时间很接近')\n        print('练习7.2-1 T(1)=T(0)+Θ(n),T(2)=T(1)+Θ(n),T(n)=T(n-1)+Θ(n)')\n        print(' 从第一个式子加到第n个式子，T(n)=Θ(n^2)')\n        print('练习7.2-2 数组A中的每个元素都相同时，也属于元素已经排序好的情况，',\n            '所以调用PARTITION子程序每次都会得到最差的分配，所以最坏情况运行时间为T(n)=Θ(n^2)')\n        print('练习7.2-3 根据书中的描写降序排序好的元素，会导致每次分配都得到最差的情况，又递归式和主定理得T(n)=Θ(n^2)')\n        print('练习7.2-4 对已经排序好的支票对于快速排序来说属于最差情况输入，运行时间为O(n^2)')\n        print(' 而对于插入排序来说却是最优输入，运行时间为O(n)')\n        print('练习7.2-5 [滑稽]但是平均的运行时间仍然为O(nlgn)')\n        print('练习7.2-6 略')\n        # python src/chapter7/chapter7note.py\n        # python3 src/chapter7/chapter7note.py\n\nclass Chapter7_3:\n    '''\n    chapter7.3 content : note, function, etc..\n\n    See Also\n    ========\n    Chapter7_1 Chapter7_2 Chapter7_4\n    '''\n    def note(self):\n        '''\n        Summary\n        ====\n        Print chapter7.3 note\n\n        Example\n        ====\n        >>> Chapter7_3().note()\n        '''\n        print('chapter7.3 note as follow')\n        print('7.3 快速排序的随机化版本')\n        print('在探讨快速排序的平均性态过程中，假定输入数据的所有排列都是等可能的')\n        print('但在工程中，这个假设就不会总是成立')\n        print('虽然第五章介绍过一些随机算法，但是如果采用一种不同的，称为随机取样的随机化技术的话，可以使分析更加简单')\n        print('在这种方法中，不是时钟采用A[r]作为主元，而是从子数组A[p..r]中随机选择一个元素')\n        print('然后将这个随机元素与A[r]交换作为主元')\n        print('因为主元元素是随机选择的，在期望的平均情况下，对输入数组的划分比较对称')\n        A = [8, 7, 6, 5, 4, 3, 2, 1]    \n        print('数组[8, 7, 6, 5, 4, 3, 2, 1]的随机化快速排序：', \n            quicksort.randomized_quicksort(A))\n        print('练习7.3-1:大部分时候输入的待排序序列我们是不知道的，而对于快速排序来讲，一个平均的输入才能反映其算法性能，最坏情况出现的概率比较小')\n        print('练习7.3-2:最佳情况调用Θ(n)次，最坏情况调用Θ(n^2)次')\n        # python src/chapter7/chapter7note.py\n        # python3 src/chapter7/chapter7note.py\n\nclass Chapter7_4:\n    '''\n    chapter7.4 content : note, function, etc..\n\n    See Also\n    ========\n    Chapter7_1 Chapter7_2 Chapter7_3\n    '''\n    def note(self):\n        '''\n        Summary\n        ====\n        Print chapter7.4 note\n\n        Example\n        ====\n        ``Chapter7_4().note()``\n        '''\n        print('chapter7.4 note as follow')\n        print('7.4 快速排序分析')\n        print('7.4.1 最坏情况分析')\n        print('如果快速排序中每一层递归上所做的都是最坏情况划分，则运行时间为Θ(n^2)')\n        print('7.4.2 期望的运行时间')\n        print('RANDOMZIED-QUICKSORT的平均情况运行时间为O(nlgn)')\n        print('运行时间和比较')\n        print('quicksort的运行时间是由花在过程PARTITION上的时间所决定的。')\n        print('每当PARTITION过程被调用时，就要选出一个主元元素，后续对QUICKSORT和PARTITION的各次递归调用中，都不会包含该元素')\n        print('于是，在快速排序算法的整个执行过程中，最多只可能调用PARTITION过程n次，调用一次PARTITION的时间为O(1)在加上一段时间')\n        print('引理7.1 设当QUICKSORT在一个包含n个元素的数组上运行时，PARTITION在第四行所做的比较次数为X,那么QUICKSORT的运行时间为O(n+X)')\n        print('练习7.4-1 递归式子T(n)=max(T(q)+T(n-q-1)+Θ(n))中，T(n)=Ω(n^2)')\n        print('练习7.4-2 快速排序的最佳情况运行时间为Ω(nlgn)')\n        print('练习7.4-3 略')\n        print('练习7.4-4 RANDOMIZED-QUICKSORT算法期望的运行时间为Ω(nlgn)')\n        print('练习7.4-5 对插入排序来说，当其输入已经是几乎排好序的，运行时间是很快的')\n        print(' 当在一个长度小于k的子数组上调用快速排序时，让它不做任何排序就返回。', \n            '当顶层的快速排序调用返回后，对整个数组运行插入排序来完成排序过程。', \n            '这一排序算法的期望运行时间为O(nk+nlg(n/k))')\n        print('练习7.4-6 PARTITION过程做这样的修改，从数组A中随机地选出三个元素，并围绕这三个数的中数(即这三个元素的中间值)进行划分', \n            '求出以a的函数形式表示的、最坏情况中a:(1-a)划分的近似概率')\n        A = [13, 19, 9, 5, 12, 8, 7, 4, 11, 2, 6, 21]\n        print('思考题7-1：数组A', _deepcopy(A), '的HOARE-PARTITION算法过程为:', \n            quicksort.hoare_partition(A, 0, len(A) - 1))\n        print('数组A', _deepcopy(A), '的HOARE-QUICKSORT的过程为：', quicksort.hoare_quicksort(A))\n        print('思考题7-2:对快速排序算法的另一种分析')\n        print(' 着重关注每一次QUICKSORT递归调用的期望运行时间，而不是执行的比较次数')\n        print(' a) 给定一个大小为n的数组，任何特定元素被选为主元的概率为1/n')\n        print('思考题7-3 Stooge排序')\n        A = [8, 7, 56, 43, 21]\n        print('数组A', _deepcopy(A), '的Stooge排序结果为:', stooge.stoogesort(A), A)\n        print('思考题7-4 快速排序的堆栈深度')\n        print(' 7.1中的快速排序算法包含有两个对其自身的递归调用,但是第二个递归不是必须的')\n        A = [8, 7, 56, 43, 21]\n        print('数组A', _deepcopy(A), '的尾递归快速排序结果为:', quicksort.morequicksort(A))\n        print('思考题7-5 \\\"三数取中\\\"划分 也就是主元素RANDOMIZED-QUICKSORT的RANDOMIZED-PARTITION过程')\n        print(' 三数取中方法仅仅影响其运行时间Ω(nlgn)中的常数因子')\n        print('思考题7-6 对区间的模糊排序:算法的目标是对这些区间进行模糊排序')\n        print('模糊排序算法的期望运行时间为Θ(nlgn),但当所有区间都重叠时，期望的运行时间为Θ(n)')\n        # python src/chapter7/chapter7note.py\n        # python3 src/chapter7/chapter7note.py\n\nchapter7_1 = Chapter7_1()\nchapter7_2 = Chapter7_2()\nchapter7_3 = Chapter7_3()\nchapter7_4 = Chapter7_4()\n\ndef printchapter7note():\n    '''\n    print chapter7 note.\n    '''\n    print('Run main : single chapter seven!')  \n    chapter7_1.note()\n    chapter7_2.note()\n    chapter7_3.note()\n    chapter7_4.note()\n\n# python src/chapter7/chapter7note.py\n# python3 src/chapter7/chapter7note.py\nif __name__ == '__main__':  \n    printchapter7note()\nelse:\n    pass\n", "meta": {"hexsha": "ac7fbdd0bf63106049014a09ace0a3faa9ca1176", "size": 8312, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/chapter7/chapter7note.py", "max_stars_repo_name": "Peefy/CLRS_dugu_code-master", "max_stars_repo_head_hexsha": "98f00e75e1b0ebc13a7affb2604bec8501692a19", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-01-31T03:08:50.000Z", "max_stars_repo_stars_event_max_datetime": "2018-04-25T12:57:01.000Z", "max_issues_repo_path": "src/chapter7/chapter7note.py", "max_issues_repo_name": "HideLakitu/IntroductionToAlgorithm.Python", "max_issues_repo_head_hexsha": "33662f46dc346203b220d7481d1a4439feda05d2", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/chapter7/chapter7note.py", "max_forks_repo_name": "HideLakitu/IntroductionToAlgorithm.Python", "max_forks_repo_head_hexsha": "33662f46dc346203b220d7481d1a4439feda05d2", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-03-03T04:49:53.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-13T10:18:58.000Z", "avg_line_length": 34.7782426778, "max_line_length": 97, "alphanum_fraction": 0.5973291627, "include": true, "reason": "from numpy", "num_tokens": 4220, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.34864513533394575, "lm_q2_score": 0.25683198001082097, "lm_q1q2_score": 0.08954322042895793}}
{"text": "# coding=utf-8\nimport numpy as np\nimport torch\nimport os\nimport torch.nn.functional as F\nimport cv2\nimport random\n\n\ndef class_weights():\n    \"\"\"\n    COCO train2014每个样本类的频率\n    是用于处理样本不均衡.\n    “样本偏斜是指数据集中正负类样本数量不均，比如正类样本有10000个，负类样本只有100个，\n    这就可能使得超平面被“推向”负类（因为负类数量少，分布得不够广），影响结果的准确性。\n    \"\"\"\n    weights = 1 / torch.FloatTensor(\n        [187437, 4955, 30920, 6033, 3838, 4332, 3160, 7051, 7677, 9167, 1316, 1372, 833, 6757, 7355, 3302, 3776, 4671,\n         6769, 5706, 3908, 903, 3686, 3596, 6200, 7920, 8779, 4505, 4272, 1862, 4698, 1962, 4403, 6659, 2402, 2689,\n         4012, 4175, 3411, 17048, 5637, 14553, 3923, 5539, 4289, 10084, 7018, 4314, 3099, 4638, 4939, 5543, 2038, 4004,\n         5053, 4578, 27292, 4113, 5931, 2905, 11174, 2873, 4036, 3415, 1517, 4122, 1980, 4464, 1190, 2302, 156, 3933,\n         1877, 17630, 4337, 4624, 1075, 3468, 135, 1380])\n    weights /= weights.sum()\n    # tensor([1.4458e-04, 5.4690e-03, 8.7642e-04, 4.4918e-03, 7.0606e-03, 6.2555e-03,\n    #         8.5756e-03, 3.8433e-03, 3.5299e-03, 2.9561e-03, 2.0592e-02, 1.9751e-02,\n    #         3.2532e-02, 4.0105e-03, 3.6844e-03, 8.2068e-03, 7.1766e-03, 5.8015e-03,\n    #         4.0034e-03, 4.7492e-03, 6.9342e-03, 3.0010e-02, 7.3518e-03, 7.5358e-03,\n    #         4.3708e-03, 3.4216e-03, 3.0868e-03, 6.0153e-03, 6.3433e-03, 1.4554e-02,\n    #         5.7682e-03, 1.3812e-02, 6.1546e-03, 4.0695e-03, 1.1282e-02, 1.0078e-02,\n    #         6.7544e-03, 6.4907e-03, 7.9445e-03, 1.5896e-03, 4.8073e-03, 1.8621e-03,\n    #         6.9077e-03, 4.8924e-03, 6.3182e-03, 2.6873e-03, 3.8613e-03, 6.2816e-03,\n    #         8.7444e-03, 5.8428e-03, 5.4867e-03, 4.8888e-03, 1.3297e-02, 6.7679e-03,\n    #         5.3629e-03, 5.9193e-03, 9.9292e-04, 6.5886e-03, 4.5690e-03, 9.3283e-03,\n    #         2.4252e-03, 9.4322e-03, 6.7143e-03, 7.9352e-03, 1.7863e-02, 6.5742e-03,\n    #         1.3686e-02, 6.0705e-03, 2.2772e-02, 1.1772e-02, 1.7371e-01, 6.8901e-03,\n    #         1.4437e-02, 1.5371e-03, 6.2483e-03, 5.8605e-03, 2.5208e-02, 7.8139e-03,\n    #         2.0073e-01, 1.9637e-02])\n\n    return weights\n\n\ndef xyxy2xywh(x):  # Convert bounding box format from [x1, y1, x2, y2] to [x, y, w, h]\n    y = torch.zeros(x.shape) if x.dtype is torch.float32 else np.zeros(x.shape)\n    y[:, 0] = (x[:, 0] + x[:, 2]) / 2\n    y[:, 1] = (x[:, 1] + x[:, 3]) / 2\n    y[:, 2] = x[:, 2] - x[:, 0]\n    y[:, 3] = x[:, 3] - x[:, 1]\n    return y\n\n\ndef xywh2xyxy(x):  # Convert bounding box format from [x, y, w, h] to [x1, y1, x2, y2]\n    y = torch.zeros(x.shape) if x.dtype is torch.float32 else np.zeros(x.shape)\n    y[:, 0] = (x[:, 0] - x[:, 2] / 2)\n    y[:, 1] = (x[:, 1] - x[:, 3] / 2)\n    y[:, 2] = (x[:, 0] + x[:, 2] / 2)\n    y[:, 3] = (x[:, 1] + x[:, 3] / 2)\n    return y\n\n\ndef bbox_iou(box1, box2, x1y1x2y2=True):\n    \"\"\"\n    Returns the IoU of two bounding boxes\n    \"\"\"\n    if x1y1x2y2:\n        # Get the coordinates of bounding boxes\n        b1_x1, b1_y1, b1_x2, b1_y2 = box1[:, 0], box1[:, 1], box1[:, 2], box1[:, 3]\n        b2_x1, b2_y1, b2_x2, b2_y2 = box2[:, 0], box2[:, 1], box2[:, 2], box2[:, 3]\n    else:\n        # Transform from center and width to exact coordinates\n        b1_x1, b1_x2 = box1[:, 0] - box1[:, 2] / 2, box1[:, 0] + box1[:, 2] / 2\n        b1_y1, b1_y2 = box1[:, 1] - box1[:, 3] / 2, box1[:, 1] + box1[:, 3] / 2\n        b2_x1, b2_x2 = box2[:, 0] - box2[:, 2] / 2, box2[:, 0] + box2[:, 2] / 2\n        b2_y1, b2_y2 = box2[:, 1] - box2[:, 3] / 2, box2[:, 1] + box2[:, 3] / 2\n\n    # get the coordinates of the intersection rectangle\n    inter_rect_x1 = torch.max(b1_x1, b2_x1)\n    inter_rect_y1 = torch.max(b1_y1, b2_y1)\n    inter_rect_x2 = torch.min(b1_x2, b2_x2)\n    inter_rect_y2 = torch.min(b1_y2, b2_y2)\n    # Intersection area\n    inter_area = torch.clamp(inter_rect_x2 - inter_rect_x1, 0) * torch.clamp(inter_rect_y2 - inter_rect_y1, 0)\n    # Union Area\n    b1_area = (b1_x2 - b1_x1) * (b1_y2 - b1_y1)\n    b2_area = (b2_x2 - b2_x1) * (b2_y2 - b2_y1)\n\n    return inter_area / (b1_area + b2_area - inter_area + 1e-16)\n\n\ndef build_targets(pred_boxes, pred_conf, pred_cls, target, anchor_wh, nA, nC, nG, batch_report):\n    \"\"\"return tx, ty, tw, th, tconf, tcls, nCorrect, nT:number of targets \"\"\"\n    nB = len(target)  # number of images in batch\n    nT = [len(x) for x in target]  # targets per image\n    tx = torch.zeros(nB, nA, nG, nG)  # nB:batch size(4)\n    ty = torch.zeros(nB, nA, nG, nG)  # nA:number of anchors(3),\n    tw = torch.zeros(nB, nA, nG, nG)  # nG:number of grid points(13) = img_dim/stride\n    th = torch.zeros(nB, nA, nG, nG)\n    tconf = torch.ByteTensor(nB, nA, nG, nG).fill_(0)  # 在函数后面加 _  是改变自身的意思\n    tcls = torch.ByteTensor(nB, nA, nG, nG, nC).fill_(0)  # nC = number of classes\n    TP = torch.ByteTensor(nB, max(nT)).fill_(0)\n    FP = torch.ByteTensor(nB, max(nT)).fill_(0)\n    FN = torch.ByteTensor(nB, max(nT)).fill_(0)\n\n    TC = torch.ShortTensor(nB, max(nT)).fill_(-1)  # target category  目标类别\n\n    for b in range(nB):\n        nTb = nT[b]  # number of targets\n        if nTb == 0:\n            continue\n        t = target[b]\n        if batch_report:\n            FN[b, :nTb] = 1\n\n        # 转换为相对于框的位置\n        TC[b, :nTb], gx, gy, gw, gh = t[:, 0].long(), t[:, 1] * nG, t[:, 2] * nG, t[:, 3] * nG, t[:, 4] * nG\n        # 获取网格框索引并防止溢出（即13个锚点上的13.01）\n        '''\n        clamp表示夹紧，夹住的意思，torch.clamp(input,min,max,out=None)-> Tensor\n        将input中的元素限制在[min,max]范围内并返回一个Tensor\n        '''\n        gi = torch.clamp(gx.long(), min=0, max=nG - 1)\n        gj = torch.clamp(gy.long(), min=0, max=nG - 1)\n\n        # iou of targets-anchors (using wh only)\n        box1 = t[:, 3:5] * nG\n        # box2 = anchor_grid_wh[:, gj, gi]\n        box2 = anchor_wh.unsqueeze(1).repeat(1, nTb, 1)\n\n        # torch.prod(input): 返回所有元素的乘积\n        inter_area = torch.min(box1, box2).prod(2)\n        iou_anch = inter_area / (gw * gh + box2.prod(2) - inter_area + 1e-16)\n\n        # Sekect best iou_pred and anchor\n        iou_anch_best, a = iou_anch.max(0)  # best anchor [0-2] for each target\n\n        # Select best unique target-anchor combinations\n        if nTb > 1:\n            iou_order = np.argsort(-iou_anch_best)  # best to worst\n\n            # Unique anchor selection(slower but retains original order)\n            u = torch.cat((gi, gj, a), 0).view(3, -1).numpy()\n            _, first_unique = np.unique(u[:, iou_order], axis=1, return_index=True)  # 第一个独特的指数\n\n            i = iou_order[first_unique]\n            # 最佳anchor必须与目标共享重要的共性（iou）\n            i = i[iou_anch_best[i] > 0.10]\n            if len(i) == 0:\n                continue\n\n            a, gj, gi, t = a[i], gj[i], gi[i], t[i]\n            if len(t.shape) == 1:\n                t = t.view(1, 5)\n        else:\n            if iou_anch_best < 0.10:\n                continue\n            i = 0\n\n        tc, gx, gy, gw, gh = t[:, 0].long(), t[:, 1] * nG, t[:, 2] * nG, t[:, 3] * nG, t[:, 4] * nG\n\n        # Coordinates  坐标\n        # b : number of images in batch\n        # a : anchor\n        tx[b, a, gj, gi] = gx - gi.float()\n        ty[b, a, gj, gi] = gy - gj.float()\n\n        # Width and height(yolo method)\n        tw[b, a, gj, gi] = torch.log(gw / anchor_wh[a, 0])\n        th[b, a, gj, gi] = torch.log(gh / anchor_wh[a, 1])\n\n        # One-hot encoding of label\n        tcls[b, a, gj, gi, tc] = 1\n        tconf[b, a, gj, gi] = 1\n\n        if batch_report:\n            # predicted classes and confidence\n            tb = torch.cat((gx - gw / 2, gy - gh / 2, gx + gw / 2, gy + gh / 2)).view(4, -1).t()  # target boxes\n            pcls = torch.argmax(pred_cls[b, a, gj, gi], 1).cpu()\n            pconf = torch.sigmoid(pred_conf[b, a, gj, gi]).cpu()\n            iou_pred = bbox_iou(tb, pred_boxes[b, a, gj, gi].cpu())\n\n            TP[b, i] = (pconf > 0.5) & (iou_pred > 0.5) & (pcls == tc)\n            FP[b, i] = (pconf > 0.5) & (TP[b, i] == 0)\n            FN[b, i] = pconf <= 0.5\n    return tx, ty, tw, th, tconf, tcls, TP, FP, FN, TC\n\n\ndef model_info(model):  # Plots a line-by-line description of a PyTorch model\n    n_p = sum(x.numel() for x in model.parameters())  # number parameters\n    n_g = sum(x.numel() for x in model.parameters() if x.requires_grad)  # number gradients\n    print('\\n%5s %50s %9s %12s %20s %12s %12s' % ('layer', 'name', 'gradient', 'parameters', 'shape', 'mu', 'sigma'))\n    for i, (name, p) in enumerate(model.named_parameters()):\n        name = name.replace('module_list.', '')\n        print('%5g %50s %9s %12g %20s %12.3g %12.3g' % (\n            i, name, p.requires_grad, p.numel(), list(p.shape), p.mean(), p.std()))\n    print('Model Summary: %g layers, %g parameters, %g gradients\\n' % (i + 1, n_p, n_g))\n\n\ndef load_classes(path):\n    \"\"\"\n    Loads class labels at 'path'\n    \"\"\"\n    fp = open(path, 'r')\n    names = fp.read().split('\\n')[:-1]\n    return names\n\n\ndef ap_per_class(tp, conf, pred_cls, target_cls):\n    \"\"\" Compute the average precision, given the recall and precision curves.\n    Method originally from https://github.com/rafaelpadilla/Object-Detection-Metrics.\n    # Arguments\n        tp:    True positives (list).\n        conf:  Objectness value from 0-1 (list).\n        pred_cls: Predicted object classes (list).\n        target_cls: True object classes (list).\n    # Returns\n        The average precision as computed in py-faster-rcnn.\n    \"\"\"\n\n    # lists/pytorch to numpy\n    tp, conf, pred_cls, target_cls = np.array(tp), np.array(conf), np.array(pred_cls), np.array(target_cls)\n\n    # Sort by objectness\n    i = np.argsort(-conf)\n    tp, conf, pred_cls = tp[i], conf[i], pred_cls[i]\n\n    # Find unique classes\n    unique_classes = np.unique(np.concatenate((pred_cls, target_cls), 0))\n\n    # Create Precision-Recall curve and compute AP for each class\n    ap, p, r = [], [], []\n    for c in unique_classes:\n        i = pred_cls == c\n        n_gt = sum(target_cls == c)  # Number of ground truth objects\n        n_p = sum(i)  # Number of predicted objects\n\n        if (n_p == 0) and (n_gt == 0):\n            continue\n        elif (n_p == 0) or (n_gt == 0):\n            ap.append(0)\n            r.append(0)\n            p.append(0)\n        else:\n            # Accumulate FPs and TPs\n            fpc = np.cumsum(1 - tp[i])\n            tpc = np.cumsum(tp[i])\n\n            # Recall\n            recall_curve = tpc / (n_gt + 1e-16)\n            r.append(tpc[-1] / (n_gt + 1e-16))\n\n            # Precision\n            precision_curve = tpc / (tpc + fpc)\n            p.append(tpc[-1] / (tpc[-1] + fpc[-1]))\n\n            # AP from recall-precision curve\n            ap.append(compute_ap(recall_curve, precision_curve))\n\n    return np.array(ap), unique_classes.astype('int32'), np.array(r), np.array(p)\n\n\ndef compute_ap(recall, precision):\n    \"\"\" Compute the average precision, given the recall and precision curves.\n    Code originally from https://github.com/rbgirshick/py-faster-rcnn.\n    # Arguments\n        recall:    The recall curve (list).\n        precision: The precision curve (list).\n    # Returns\n        The average precision as computed in py-faster-rcnn.\n    \"\"\"\n    # correct AP calculation\n    # first append sentinel values at the end\n\n    mrec = np.concatenate(([0.], recall, [1.]))\n    mpre = np.concatenate(([0.], precision, [0.]))\n\n    # compute the precision envelope\n    for i in range(mpre.size - 1, 0, -1):\n        mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])\n\n    # to calculate area under PR curve, look for points\n    # where X axis (recall) changes value\n    i = np.where(mrec[1:] != mrec[:-1])[0]\n\n    # and sum (\\Delta recall) * prec\n    ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])\n    return ap\n\n\ndef non_max_suppression(prediction, conf_thres=0.5, nms_thres=0.4):\n    \"\"\"\n    Removes detections with lower object confidence score than 'conf_thres' and performs\n    Non-Maximum Suppression to further filter detections.\n    Returns detections with shape:\n        (x1, y1, x2, y2, object_conf, class_score, class_pred)\n    \"\"\"\n\n    output = [None for _ in range(len(prediction))]\n    for image_i, pred in enumerate(prediction):\n        # Filter out confidence scores below threshold\n        # Get score and class with highest confidence\n\n        # cross-class NMS (experimental)\n        cross_class_nms = False\n        if cross_class_nms:\n            # thresh = 0.85\n            thresh = nms_thres\n            a = pred.clone()\n            _, indices = torch.sort(-a[:, 4], 0)  # sort best to worst\n            a = a[indices]\n            radius = 30  # area to search for cross-class ious\n            for i in range(len(a)):\n                if i >= len(a) - 1:\n                    break\n\n                close = (torch.abs(a[i, 0] - a[i + 1:, 0]) < radius) & (torch.abs(a[i, 1] - a[i + 1:, 1]) < radius)\n                close = close.nonzero()\n\n                if len(close) > 0:\n                    close = close + i + 1\n                    iou = bbox_iou(a[i:i + 1, :4], a[close.squeeze(), :4].reshape(-1, 4), x1y1x2y2=False)\n                    bad = close[iou > thresh]\n\n                    if len(bad) > 0:\n                        mask = torch.ones(len(a)).type(torch.ByteTensor)\n                        mask[bad] = 0\n                        a = a[mask]\n            pred = a\n\n        x, y, w, h = pred[:, 0], pred[:, 1], pred[:, 2], pred[:, 3]\n        a = w * h  # area\n        ar = w / (h + 1e-16)  # aspect ratio\n\n        log_w, log_h, log_a, log_ar = torch.log(w), torch.log(h), torch.log(a), torch.log(ar)\n\n        # n = len(w)\n        # shape_likelihood = np.zeros((n, 60), dtype=np.float32)\n        # x = np.concatenate((log_w.reshape(-1, 1), log_h.reshape(-1, 1)), 1)\n        # from scipy.stats import multivariate_normal\n        # for c in range(60):\n        # shape_likelihood[:, c] = multivariate_normal.pdf(x, mean=mat['class_mu'][c, :2], cov=mat['class_cov'][c, :2, :2])\n\n        class_prob, class_pred = torch.max(F.softmax(pred[:, 5:], 1), 1)\n\n        v = ((pred[:, 4] > conf_thres) & (class_prob > .3))\n        v = v.nonzero().squeeze()\n        if len(v.shape) == 0:\n            v = v.unsqueeze(0)\n\n        pred = pred[v]\n        class_prob = class_prob[v]\n        class_pred = class_pred[v]\n\n        # If none are remaining => process next image\n        nP = pred.shape[0]\n        if not nP:\n            continue\n\n        # From (center x, center y, width, height) to (x1, y1, x2, y2)\n        box_corner = pred.new(nP, 4)\n        xy = pred[:, 0:2]\n        wh = pred[:, 2:4] / 2\n        box_corner[:, 0:2] = xy - wh\n        box_corner[:, 2:4] = xy + wh\n        pred[:, :4] = box_corner\n\n        # Detections ordered as (x1, y1, x2, y2, obj_conf, class_prob, class_pred)\n        detections = torch.cat((pred[:, :5], class_prob.float().unsqueeze(1), class_pred.float().unsqueeze(1)), 1)\n        # Iterate through all predicted classes\n        unique_labels = detections[:, -1].cpu().unique()\n        if prediction.is_cuda:\n            unique_labels = unique_labels.cuda(prediction.device)\n\n        nms_style = 'OR'  # 'AND' or 'OR' (classical)\n        for c in unique_labels:\n            # Get the detections with the particular class\n            detections_class = detections[detections[:, -1] == c]\n            # Sort the detections by maximum objectness confidence\n            _, conf_sort_index = torch.sort(detections_class[:, 4], descending=True)\n            detections_class = detections_class[conf_sort_index]\n            # Perform non-maximum suppression\n            max_detections = []\n\n            if nms_style == 'OR':  # Classical NMS\n                while detections_class.shape[0]:\n                    # Get detection with highest confidence and save as max detection\n                    max_detections.append(detections_class[0].unsqueeze(0))\n                    # Stop if we're at the last detection\n                    if len(detections_class) == 1:\n                        break\n                    # Get the IOUs for all boxes with lower confidence\n                    ious = bbox_iou(max_detections[-1], detections_class[1:])\n\n                    # Remove detections with IoU >= NMS threshold\n                    detections_class = detections_class[1:][ious < nms_thres]\n\n            elif nms_style == 'AND':  # 'AND'-style NMS, at least two boxes must share commonality to pass, single boxes erased\n                while detections_class.shape[0]:\n                    if len(detections_class) == 1:\n                        break\n\n                    ious = bbox_iou(detections_class[:1], detections_class[1:])\n\n                    if ious.max() > 0.5:\n                        max_detections.append(detections_class[0].unsqueeze(0))\n\n                    # Remove detections with IoU >= NMS threshold\n                    detections_class = detections_class[1:][ious < nms_thres]\n\n            if len(max_detections) > 0:\n                max_detections = torch.cat(max_detections).data\n                # Add max detections to outputs\n                output[image_i] = max_detections if output[image_i] is None else torch.cat(\n                    (output[image_i], max_detections))\n\n    return output\n\n\ndef write_cfg(cfgfile, cfg, precent):\n    with open(cfgfile, 'r') as f:\n        lines = f.read().split('\\n')  # store the lines in a list\n        lines = [x for x in lines if len(x) > 0]  # get read of the empty lines\n        lines = [x for x in lines if x[0] != '#']  # get rid of comments\n        # lines = [x.rstrip().lstrip() for x in lines]  # get rid of fringe whitespaces\\\n\n    block = {}\n    blocks = []\n    # D:/yolotest/cfg/yolov3.cfg\n    # prunedcfg = os.path.join('./'.join(cfgfile.split(\"/\")[0:-1]), \"prune_\" + cfgfile.split(\"/\")[-1])\n    if not os.path.exists('sparsity_2_prune_cfg'):\n        os.mkdir('sparsity_2_prune_cfg')\n    prunedcfg = os.path.join(\"sparsity_2_prune_cfg/prune_{}_\".format(precent) + cfgfile.split(\"/\")[-1])\n    for line in lines:\n        if line[0] == \"[\":  # This marks the start of a new block\n            if len(block) != 0:  # If block is not empty, implies it is storing values of previous block.\n                blocks.append(block)  # add it the blocks list\n                block = {}  # re-init the block\n            block[\"type\"] = line[1:-1].rstrip()\n        else:\n            key, value = line.split(\"=\")\n            block[key.rstrip()] = value.lstrip()\n    blocks.append(block)\n    x = 0\n    # print(blocks[1])\n    for block in blocks:\n        if 'batch_normalize' in block:\n            block['filters'] = cfg[x]\n            x = x + 1\n    ##\n    with open(prunedcfg, 'w') as f:\n        for block in blocks:\n            for i in block:\n                if i == \"type\":\n                    f.write('\\n')\n                    f.write(\"[\" + block[i] + \"]\\n\")\n                    for j in block:\n                        if j != \"type\":\n                            f.write(j + \"=\" + str(block[j]) + '\\n')\n    print('save pruned cfg file in %s' % prunedcfg)\n    return prunedcfg\n\n\ndef route_problem(model, ind):\n    ds = list(model.children())\n    dsas = list(ds[0].children())\n\n    # print('-----------',dsas[90])\n    sum1 = 0\n    # print(dsas[90].named_children())\n    for k in range(ind + 1):\n        # print('k:',k)\n        for i in dsas[k].named_children():\n            # print('i:',i)\n            if \"_\".join(i[0].split(\"_\")[0:-1]) == 'conv_with_bn':\n                sum1 = sum1 + 1\n    # print(sum1)\n    return sum1 - 1\n\n\ndef dontprune(model):\n    dontprune = []\n    nnlist = model.module_list\n    for i in range(len(nnlist)):\n        for name in nnlist[i].named_children():\n            if name[0].split(\"_\")[0] == 'shortcut':\n                if 'conv' in list(nnlist[name[1].froms + i].named_children())[0][0]:\n                    dontprune.append(name[1].froms + i)\n                else:\n                    dontprune.append(name[1].froms + i - 1)\n                dontprune.append(i - 1)\n    return dontprune\n\n\ndef coco_class_count(path='../coco/labels/train2014/'):\n    import glob\n\n    nC = 80  # number classes\n    x = np.zeros(nC, dtype='int32')\n    files = sorted(glob.glob('%s/*.*' % path))\n    for i, file in enumerate(files):\n        labels = np.loadtxt(file, dtype=np.float32).reshape(-1, 5)\n        x += np.bincount(labels[:, 0].astype('int32'), minlength=nC)\n        print(i, len(files))\n\n\ndef plot_results():\n    # Plot YOLO training results file 'results.txt'\n    import glob\n    import numpy as np\n    import matplotlib.pyplot as plt\n    plt.figure(figsize=(16, 8))\n    s = ['X', 'Y', 'Width', 'Height', 'Objectness', 'Classification', 'Total Loss', 'Precision', 'Recall', 'mAP']\n    files = sorted(glob.glob('results*.txt'))\n    for f in files:\n        results = np.loadtxt(f, usecols=[2, 3, 4, 5, 6, 7, 8, 17, 18, 16]).T  # column 16 is mAP\n        n = results.shape[1]\n        for i in range(10):\n            plt.subplot(2, 5, i + 1)\n            plt.plot(range(1, n), results[i, 1:], marker='.', label=f)\n            plt.title(s[i])\n            if i == 0:\n                plt.legend()\n\n\ndef plot_one_box(x, img, color=None, label=None, line_thickness=None):  # Plots one bounding box on image img\n    tl = line_thickness or round(0.002 * max(img.shape[0:2])) + 1  # line thickness\n    color = color or [random.randint(0, 255) for _ in range(3)]\n    c1, c2 = (int(x[0]), int(x[1])), (int(x[2]), int(x[3]))\n    cv2.rectangle(img, c1, c2, color, thickness=tl)\n    if label:\n        tf = max(tl - 1, 1)  # font thickness\n        t_size = cv2.getTextSize(label, 0, fontScale=tl / 3, thickness=tf)[0]\n        c2 = c1[0] + t_size[0], c1[1] - t_size[1] - 3\n        cv2.rectangle(img, c1, c2, color, -1)  # filled\n        cv2.putText(img, label, (c1[0], c1[1] - 2), 0, tl / 3, [225, 255, 255], thickness=tf, lineType=cv2.LINE_AA)\n\n# def model_info(model, report='full'):\n#     # Plots a line-by-line description of a PyTorch model\n#     n_p = sum(x.numel() for x in model.parameters())  # number parameters\n#     n_g = sum(x.numel() for x in model.parameters() if x.requires_grad)  # number gradients\n#     if report is 'full':\n#         print('%5s %40s %9s %12s %20s %10s %10s' % ('layer', 'name', 'gradient', 'parameters', 'shape', 'mu', 'sigma'))\n#         for i, (name, p) in enumerate(model.named_parameters()):\n#             name = name.replace('module_list.', '')\n#             print('%5g %40s %9s %12g %20s %10.3g %10.3g' %\n#                   (i, name, p.requires_grad, p.numel(), list(p.shape), p.mean(), p.std()))\n#     print('Model Summary: %g layers, %g parameters, %g gradients' % (len(list(model.parameters())), n_p, n_g))\n", "meta": {"hexsha": "32d84854c6dcd00ae368d503d0daec72b3f8b852", "size": 22363, "ext": "py", "lang": "Python", "max_stars_repo_path": "utils/utils.py", "max_stars_repo_name": "shentanyue/Pytorch-yolov3-trainv3", "max_stars_repo_head_hexsha": "26d85c82fdfc7bef7c2b6e70b56a9e2c254a81bf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-01-29T07:12:57.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-05T10:21:58.000Z", "max_issues_repo_path": "utils/utils.py", "max_issues_repo_name": "shentanyue/Pytorch-yolov3-prune-faster", "max_issues_repo_head_hexsha": "26d85c82fdfc7bef7c2b6e70b56a9e2c254a81bf", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-06-13T08:37:04.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-13T08:37:04.000Z", "max_forks_repo_path": "utils/utils.py", "max_forks_repo_name": "shentanyue/Pytorch-yolov3-prune-faster", "max_forks_repo_head_hexsha": "26d85c82fdfc7bef7c2b6e70b56a9e2c254a81bf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.9578754579, "max_line_length": 127, "alphanum_fraction": 0.5491660332, "include": true, "reason": "import numpy,from scipy", "num_tokens": 7548, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.17328821019878957, "lm_q1q2_score": 0.08935085233849209}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# TODO:\n# -\tget the unit renaming in the columns working with regex in `ac_representation_tool`\n# \n# -\tfigure out why the sym and symbolic all-pass filter diverge from each other\n# \n# -\tcreate a table of low-high pass vs rc & rl\n# \n# -\tlook into ngspice internals and really verify that there are no \n# equivalencies to dc internals with .ac sims\n# \n# Most likely will do this in another section further down the road\n# \n# -\tadd filter design tool and filter circuit generation tool; see isbn 978-0-387-92766-4 and things like cauer network tf implimentation\n# \n# -\tdiscuss L->C passive conversion\n# \n\n# In[1]:\n\n\nfrom skidl.pyspice import *\n#can you say cheeky \nimport PySpice as pspice\n#becouse it's written by a kiwi you know\nimport lcapy as kiwi\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport sympy as sym\n\n\nfrom IPython.display import YouTubeVideo, display\n\nimport traceback\nimport warnings\n\n\n# In[2]:\n\n\n#import dc code from parral folder\nimport sys\nsys.path.insert(1, '../DC_1/')\nfrom DC_1_Codes import get_skidl_spice_ref\n#from AC_2_Codes import \n\nsym.init_printing()\n\n#notebook specific loading control statements \nget_ipython().run_line_magic('matplotlib', 'inline')\n#tool to log notebook internals\n#https://github.com/jrjohansson/version_information\nget_ipython().run_line_magic('load_ext', 'version_information')\nget_ipython().run_line_magic('version_information', 'skidl, PySpice,lcapy, sympy, numpy, matplotlib, pandas, scipy')\n\n\n# # Basic Passive Filters\n# \n# In this section, we will construct and look at the basic passive analog filters constructed of RLC elements only. For now, we will just develop an ac equivalent tool to `dc_ease` that was in the last chapter. As well as some basic data manipulation, plotting tool, and classes for the RLC primitive filters. For advanced tools filter analysis will be developed later in this chapter in section asdlkjfaljdfkj where then we can compare not only the SPICE simulation data but also the SPICE generated Pole-Zero Transfer function and the theoretical transfer function to each other in greater detail.\n# \n\n# ## The RC Low Pass Filter¶\n# \n# The RC filter is a first-order single-pole filter. Where the pole is realized physically by a shunt capacitor. For more technical details about an RC low pass filter consult the YT video by ALL ABOUT ELECTRONICS \"RC Low Pass Filter Explained\" that serves as the example source below\n# \n\n# ### The low pass RC filter from ALL ABOUT ELECTRONICS \"RC Low Pass Filter Explained\" @~ 8:35min\n\n# In[3]:\n\n\nYouTubeVideo('_2L0l-E1Wx0', width=500, height=400, start=515)\n\n\n# ### RC Low Pass Filter Subcircuit container class\n# \n# The class below is the first in a series of classes developed in this section to create and store information about the filter primitive under test. For each of these primitives we will create a class that does three things:\n# \n# -\tstores the filter element values in the class initiation method\n# \n# -\tgenerates the filter and its elements inside a SKiDl subcircuit to then included in the circuit under design\n# \n# -\tprovides a schematic representation method of the filter being constructed by this class via lcapy\n# \n# -\tprovides the transfer function and two-port representation of the filter in sympy via its own methods by using the lcapy schematic \n# \n# We see how this is done with the RC Low Pass filter first below\n# \n\n# In[4]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 rc_lowpass filter class\n#class with lcapy and skidl subcircuit to create an RC lowpass filter\n\nclass rc_lowpass():\n    \"\"\"\n    holding class for SkiDl subcircuit and lcapy schematic of a\n    lowpass RC filter primitive\n    \"\"\"\n    \n    def __init__(self, subcirc_ref=None, C_value=1@u_F, R_value=1@u_Ohm):\n        \"\"\"\n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            C_value (float; 1@u_F; Farads): the capacitance in farads for the RC capacitive element\n            R_value (float; 1@u_Ohm; Ohms): the resistance in ohms for the RC resistive element\n\n        Returns:\n            None\n        TODO:\n            -add assertions\n        \"\"\"\n        #add assertions\n        self.subcirc_ref=subcirc_ref\n        self.C_value=C_value\n        self.R_value=R_value\n        \n\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - RC_Lowpass - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RC lowpass filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        if self.subcirc_ref!=None:\n            Cref={'ref':f'C_{self.subcirc_ref}'}\n            Rref={'ref':f'R_{self.subcirc_ref}'}\n        else:\n            Cref={}\n            Rref={}\n            \n        self.c=C(value=self.C_value, **Cref)\n        self.r=R(value=self.R_value, **Rref)\n        \n        self.r[1, 2]+=term_0, self.c['p']\n        self.c['p', 'n']+=term_2, term_3\n        \n        if return_elements:\n            return self.c, self.r\n    \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class filter, extract the transfer function, \n        exstract the 2Port Repersntation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes filter schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract simply variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - get the Vin statement into the schematic\n        \n        \"\"\"\n        self.with_values=with_values\n        \n        \n        self.schematic=kiwi.Circuit()\n        self.schematic.add('W 1 1_1; right=2')\n        self.schematic.add('W 0 0_1; right')\n        #self.schematic.add('P1 0 1; down, v=V_i')\n        \n        self.schematic.add('R 0_1 2_1; right')\n        self.schematic.add('C 2_1 1_1; down')\n        \n        self.schematic.add('W 2_1 2; right=1.5')\n        self.schematic.add('W 1_1 3; right=1.5')\n        self.schematic.add('P2 2 3; down, v=V_o')\n        \n        if with_values:\n            self.schematic=self.schematic.subs({'R':self.R_value, 'C':self.C_value})\n        \n        if draw_me:\n            self.schematic.draw()\n    \n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n        \n            \n        \n        \n\n\n# In the method for the subcircuit `SKiDl` above we referenced a port-terminal convention from a library **scikit-rf**. This is the main python library for S-parameter analysis and primitive rf circuit design in the Python scientific ecosystem. Where we will interact with it at length in the following sections but for now let's just get in the habit of using their port-terminal convention since we are coding all this up in python\n\n# Below we instantiate the filter to the values found in the reference example above and draw it\n\n# In[5]:\n\n\n#instatate the rc_lowpass filter to \nlowpassF=rc_lowpass(C_value=.1@u_uF, R_value=1@u_kOhm)\nlowpassF.lcapy_self()\n\n\n# Nest using `lcapy` we can use the circuit we created in `rc_lowpass.lcapy_self` to then extract the voltage transfer function coming from the Port 0 & 1 Terminals to the Port 2 & 3 Terminals. Where the method has been abstracted such that it can be called to just get the symbolic equation or get the symbolic equation with the values of this particular instance substituted into the symbolic expression.\n\n# In[6]:\n\n\n#get this filters abstract transfer function\nlowpassF.get_tf(with_values=False)\n\n\n# In[7]:\n\n\n#get this filters transfer function\nlowpassF.get_tf(with_values=True)\n\n\n# and finally, we will now use the lowpass filter in its primary utilization as part of a circuit to be simulated with SPICE.\n\n# In[8]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out'); \n\n#create a 1V AC test source and attache to nets\nvs=SINEV(ac_magnitude=1@u_V); vs['p', 'n']+=net_in, gnd\n\n#attaceh term_0 to net_in and term_2 to net_out per scikit-rf convention all \n#other terminals are grounded\nlowpassF.SKiDl(net_in, gnd, net_out, gnd)\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# ### making ac_ease¶\n# \n# In the last chapter, we developed a class `dc_ease` to make running the .dc SPICE simulation more automated. Here we will develop an analogies class `ac_ease` to automate the .ac simulation. There are some differences thou. For one with .dc simulation, we could sweep over any variable (I still need to fix pyspice to do that); whereas we learned in the last section that .ac simulation only allows us to sweep the operating frequency of all our sources simultaneously and observe the response of the circuit to each frequency in terms of Fourier transform terms. The second thing is that .dc simulations allowed us to access a plethora of circuit elements' internal parameters to record things such as current and power without having to add SPICE ammeter all over the place. While .ac does not have quite that support in ngspice (see typically chapter 31 \"Model and Device Parameters\" in the ngspice manual). So we are going to forgo do internal parameters in `ac_ease`.\n# \n# \n\n# Also, in the last section, we just used the \"linear\" sweep capability of an ac simulation. However, AC simulations are more commonly done via logarithm sweeps. This is akin to `np.logspace`, however, unlike NumPy's logspace, we till .ac what the starting and stop are and how many samples we want per decade. And then there is the less used \" octave \" sampling scheme where there is no numpy kin. Octave takes the starting frequency, say 1kHz, and then computes the doubles of it (think octaves in music) and then samples within that doubling. So 1kHz doubles to 2kHz and so on till the stop frequency is reached while getting n samples within each double via the \"number_of_points\" argument in the .ac simulation control.\n\n# In[9]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 ac_ease class\n#class to perform .ac simulations with a bit more grace\n\nclass ac_ease():\n    \"\"\"\n    Class to perform AC (.ac) SPICE simulation with some grace; \n    currently limited to what pyspice and ngspice support\n    \n    TODO:\n        - independent current sources can have their AC current measured via \n        `@I<name>[acreal]` & `@I<name>[acrimag]` not shure if this is usefull\n        also trying via the sensitivity \n        - do some serious testing with ngspice directly to verify that internal\n        parameters are as limited as they appear to be with .ac\n        \n    \"\"\"\n    def __init__(self, circ_netlist_obj):\n        \"\"\"\n        Class to perform AC (.ac) SPICE simulation with some grace\n        \n        Args:\n            circ_netlist_obj (pyspice.Spice.Netlist.Circuit): the Netlist circuit produced \n                from SKiDl's `generate_netlist()`\n        \n        Returns: \n            creates a table to control the ac sweep `self.fsweep_DF`\n            this table will still need to be filled out before a simulation can be run with `self.do_ac_sim`\n            can be filled out manually or with the helper method `self.ac_sweep_setup`\n        \"\"\"\n        self.circ_netlist_obj=circ_netlist_obj\n        self._build_table()\n        \n        #dic of allowed AC sweep types\n        self.allowed_steptypes_map={'linear':'lin', 'decade':'dec', 'octave': 'oct'}\n\n    \n    def _build_table(self):\n        \"\"\"\n        protected method to create `self.fsweep_DF` dataframe that stores the controls for the ac simulation\n        \n        TODO:\n            -when pyspice accepts more things to sweep add them below\n        \"\"\"\n        self.fsweep_DF=pd.DataFrame(columns=['Start_freq', 'Stop_Freq', 'SamplingInc', 'StepType'])\n        self.fsweep_DF.at[len(self.fsweep_DF)]=[.1@u_Hz, 120@u_GHz, 10, 'decade']\n\n    def ac_sweep_setup(self, Start_freq, Stop_Freq, SamplingInc, StepType, display_table=False):\n        \"\"\"\n        Helper method to create the `self.fsweep_DF` to control the ac simulation\n        \n        Args:\n            Start_freq (Hertz): starting frequency in Hertz of the ac simulation, must be less than `Stop_Freq` and can\n                only be zero if `StepType='linear'`\n            \n            Stop_Freq (Hertz): stoping  frequency in Hertz of the ac simulation, must be greater than `Start_freq` \n            \n            SamplingInc (int): number of samples per StepType interval\n            \n            StepType (string): string control for the ac simulation Step type.\n                must be 'linear' (self-explanatory), 'decade' (log base 10 sampling interval), \n                or 'octave' (starting frequency times 2**n to create sample space a double of the starting frequency\n                so that samples are pulled from 2**(n-1) and 2**(n) times the starting frequency)\n            \n            display_table (bool; False): when true will display the generated `self.fsweep_DF` below\n             this method call in a jupyter notebook like environment\n            \n        TODO:\n            -add display action\n        \"\"\"\n        #check for allowed step types\n        assert StepType in self.allowed_steptypes_map.keys(),  f\"{StepType} is not allowed\"\n        #force start to non zero if sweep not linear\n        if StepType != 'linear':\n            if float(Start_freq)==0:\n                warnings.warn('\"linear\" is only sweep type that can start at 0Hz,\\n setting starting frequancy to 1e-1Hz')\n                Start_freq=1e-1@u_Hz\n                \n                \n        #check that stop frequency is greater than start\n        assert Stop_Freq>Start_freq, 'Stop frequency must be greater then starting frequency'\n        \n        self.fsweep_DF.at[0]=[Start_freq, Stop_Freq, SamplingInc, StepType]\n        \n        if display_table:\n            display(self.fsweep_DF)\n    \n    def _make_sim_control(self):\n        \"\"\"\n        Internal method to extract the row information to the .ac pyspice call arguments\n        Will raise a warning if the simulation start frequency is 0Hz for non-linear frequency sampling and \n        then set the start frequency to .1Hz\n        \n        Args:\n            NONE\n            \n        Returns:\n            `self.ac_control` what is feed into the .ac to do the simulation over a frequency\n            \n        \"\"\"\n        \n        #check the control table struct\n        assert (self.fsweep_DF.columns==['Start_freq', 'Stop_Freq', 'SamplingInc', 'StepType']).all(), 'Contorl Table Column structer has been altered'\n        \n        #will probably change this down the road\n        assert len(self.fsweep_DF)==1, 'there should only be one entry in the control table'\n        \n        #check the sweep type\n        self.fsweep_DF['StepType'][0] in self.allowed_steptypes_map.keys(), f\"{self.fsweep_DF['StepType'][0]} is not allowed\"\n        \n        #check that stop frequency is greater than start\n        assert self.fsweep_DF.at[0, 'Stop_Freq']>self.fsweep_DF.at[0, 'Start_freq'], 'Stop freqauncy must be grater then starting freauncy'\n        \n        #force start to non zero if sweep not linear\n        if self.fsweep_DF['StepType'][0] != 'linear':\n            if float(self.fsweep_DF['Start_freq'][0])==0:\n                warnings.warn('\"linear\" is only sweep type that can start at 0Hz,\\n setting starting frequancy to 1e-1Hz')\n                self.fsweep_DF.at[0, 'Start_freq']=1e-1@u_Hz\n        \n        self.ac_control={\n            'start_frequency':self.fsweep_DF.at[0, 'Start_freq'], \n            'stop_frequency':self.fsweep_DF.at[0, 'Stop_Freq'], \n            'number_of_points':self.fsweep_DF.at[0, 'SamplingInc'],\n            'variation': self.allowed_steptypes_map[self.fsweep_DF.at[0, 'StepType']]\n        }\n        \n        \n        \n    \n    def do_ac_sim(self):\n        \"\"\"\n        Does a standard Branch and Node .ac simulation for the single filled out row in `self.fsweep_DF`\n        \n        Args:\n            None\n        \n        Returns: \n            raw results are stored in `self.ac_vals`, processed results are automatically stored in \n            `self.ac_resultsNB_DF` via `self.record_ac_nodebranch`\n        \"\"\"\n        self._make_sim_control()\n        self.sim=self.circ_netlist_obj.simulator()\n        self.ac_vals=self.sim.ac(**self.ac_control)\n        \n        self.record_ac_nodebranch()\n\n    \n    def record_ac_nodebranch(self):\n        \"\"\" \n        Helper method to put .ac node branch results into a dataframe where the index is the \n        sweep frequency used in the simulation\n        \n        Args:\n            None\n        \n        Returns:\n            `self.ac_resultsNB_DF` which is a pandas dataframe with the index being the sweep frequency\n            and the columns being the node voltages and branch currents from any available voltage sources  \n            \n        TODO:\n            look into getting the current in any current sources\n            \n        \"\"\"\n        self.ac_resultsNB_DF=pd.DataFrame(index=self.ac_vals.frequency.as_ndarray())\n        self.ac_resultsNB_DF.index.name='freq[Hz]'\n        \n        #get the node voltages\n        for n in self.circ_netlist_obj.node_names:\n            if n=='0':\n                continue\n            self.ac_resultsNB_DF[n+'_[V]']=self.ac_vals[n].as_ndarray()\n        \n        #get the current from any voltage source\n        for cm in self.circ_netlist_obj.element_names:\n            if 'V'==cm[0]:\n                self.ac_resultsNB_DF[cm+'_[A]']=-self.ac_vals[cm].as_ndarray()\n                \n\n\n# In[10]:\n\n\n#instainte the simulation from the circuit\nac_sweep=ac_ease(circ)\n#setup the simulation parameter with the helper method\nac_sweep.ac_sweep_setup(0, 100@u_MHz, 10, 'decade', True)\n\n\n# In[11]:\n\n\nac_sweep.do_ac_sim()\nac_sweep.ac_resultsNB_DF\n\n\n# ### making a basic ac data conversion tool\n# \n# As we learned in the last section since the returns of an AC simulation are complex values we have to represent the values in order to just plot the values. The following class has methods that will allow us to pass in the raw results of the AC simulation and then perform reinterpretation of the values as needed\n# \n\n# In[12]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 ac_representation_tool class\n#class that converts dataframe of raw ac complex data to veries complex\n#repsentations \n\nclass ac_representation_tool:\n    \"\"\"\n    Class to take a dataframe with AC simulation complex value data and\n    represent it in various ways. raw data should come from `ac_ease.ac_resultsNB_DF`\n    \n    TODO:\n        -get the unit renaming in the columns working with regex\n    \"\"\"\n    \n    def __init__(self, ac_sim_raw_DF):\n        \"\"\"\n        pull in the data\n        Args:\n            ac_sim_raw_DF (pandas dataframe): pandas dataframe of raw data from AC simulation \n                preferbyly from `ac_ease.ac_resultsNB_DF`, index must be the simulation\n                frequency and columns must be the complex data\n        \n        Returns: \n            None\n        \n        TODO:\n            broaden complex assertin to include np.complex128\n        \"\"\"\n        #write asserts for ac_sim_DF\n        assert repr(type(ac_sim_raw_DF))==\"<class 'pandas.core.frame.DataFrame'>\", '`ac_sim_raw_DF` must be a dataframe'\n        #check that all columns from raw data are complex\n        assert (ac_sim_raw_DF.dtypes==np.complex64).all() or (ac_sim_raw_DF.dtypes==np.complex128).all(), 'Raw data must be complex from AC sim'\n        self.ac_sim_raw_DF=ac_sim_raw_DF\n    \n    def make_real_imag(self):\n        \"\"\"\n        Method to create a real and image version of the raw data\n\n        Args: None\n        \n        Returns:\n            real values are stored in `self.ac_sim_real_DF`; and \n            imaginary values are stored in `self.ac_sim_imag_DF`\n            \n        \"\"\"\n        \n        self.ac_sim_real_DF=self.ac_sim_raw_DF.apply(np.real, axis=0)\n        \n        self.ac_sim_imag_DF=self.ac_sim_raw_DF.apply(np.imag, axis=0)\n        \n    \n    def make_mag_phase(self, mag='dB', char_res=50, deg=True, phase_unwrap=True):\n        \"\"\"\n        Method to make generate the various magnitude and phase representation of the complex data\n        \n        Args:\n            mag (string, \"dB\"): control statement to specify the representation of the generated \n                magnitude data; right now only 'dB' and 'abs' are supported\n            \n            char_res (float; 50; ohms): the characteristic impedance for magnitude representation calculations; not \n                implemented at the moment\n            \n            deg (bool; True): bool control statement to represent the phase data in degrees if True; else in radians\n            \n            phase_unwrap (bool; True): when True and `deg` is True will represent the degrees in phased unwrapped\n        \n        Returns:\n            magnitude data is stored in `self.ac_sim_mag_DF` and phase data is stored in `self.ac_sim_phase_DF`\n        \n        TODO: \n            -complete all of the magnitude conversions\n        \"\"\"\n        #deal with the cacophony of magnitudes\n        mag_conversions={\n            'dB': lambda x: 10*np.log10(np.abs(x)) if x.name in ['[W]', '[VAR]', '[VA]'] else 20*np.log10(np.abs(x)), \n            'abs': lambda x: np.abs(x)\n        }\n        \n        #check the input\n        assert mag in mag_conversions.keys(), f'{mag} is not a known magnitude repsentation'\n         \n        self.ac_sim_mag_DF=self.ac_sim_raw_DF.apply(mag_conversions[mag], axis=0)\n        \n        #redo the column name units\n        #get down with the regex to really do this\n        if mag in ['dB']:\n            self.ac_sim_mag_DF.rename(columns={i:i+'[dB]' for i in self.ac_sim_mag_DF.columns}, inplace=True)\n        \n        #deal with the phase\n        \n        if (deg==True) and (phase_unwrap==True):\n            #phase unwrapped lambda function\n            angle_phase_unwrap= lambda x: np.rad2deg(np.unwrap(np.angle(x)))\n\n            self.ac_sim_phase_DF=self.ac_sim_raw_DF.apply(angle_phase_unwrap, axis=0)\n        \n        else:\n            self.ac_sim_phase_DF=self.ac_sim_raw_DF.apply(np.angle, axis=0, deg=deg)\n\n        #realy need that stupid regex working\n        \n        if deg:\n            self.ac_sim_phase_DF.rename(columns={i:i+'[deg]' for i in self.ac_sim_phase_DF.columns}, inplace=True)\n        else:\n            self.ac_sim_phase_DF.rename(columns={i:i+'[rads]' for i in self.ac_sim_phase_DF.columns}, inplace=True)\n\n\n# In[13]:\n\n\nac_rep_tool=ac_representation_tool(ac_sweep.ac_resultsNB_DF)\nac_rep_tool.make_real_imag()\nac_rep_tool.ac_sim_real_DF\n\n\n# In[14]:\n\n\nac_rep_tool.make_mag_phase()\nac_rep_tool.ac_sim_mag_DF\n\n\n# ### Making a complex representation plotting templet¶\n# \n# Here we are going to make a class the store plot templets for the 3+1 major representations of complex values:\n# \n# -\tBode Plot with Magnitude and Phase on the same plot: The Bode plot is the most widely used plot of complex data that is parametric to the frequency which we use as the x-axis. This is one of two standard variations of the Bode plot where the Magnitude and Phase is plotted on the same graph using twin axis\n# \n# -\tBode Plot with Magnitude and Phase on the separate plots: In this version of the Bode plot the x-axis is still the frequency and there are two subplots sharing the same x-axis with the top plot being the magnitude plot and the bottom being the phase\n# \n# -\tNichols Plot: This is a parametric plot where the x-axis and the phase and the y-axis is the magnitude and direction is indicated by an arrow along the line showing the direction of frequency increase. This plot is used more in Feedback and Control system design.\n# \n# -\tNyquist Plot: This is a parametric plot where the x-axis and the real part and the y-axis is the imaginary part and direction is indicated by an arrow along the line showing the direction of frequency increase. This plot is used more in Feedback and Control system design.\n# \n# This class contains templets since an existing matplotlib axis can be passed through them to then include them in more advanced plots with additional information being able to be added to the axis. Or these plot methods can be called without any axis passed to them to then generate a basic plot\n# \n# \n\n# In[15]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 eecomplex_plot_templets class\n#class that stores templets plots for most common complex rep plots\n\nclass eecomplex_plot_templets():\n    \"\"\"\n    Class that stores basic/common Electrical Engineering Complex value\n    representation plots that may be used stand-alone or as templets in other plots \n    with refinements\n    \"\"\"\n    def __init__(self):\n        pass\n    \n    def bode_plot_one_templet(self, freq_data, mag_data, phase_data, ax=None, title=''):\n        \"\"\"\n        Templet plot to make a Bode plot with Magnitude and Phase all in one\n        graph using a twinx. \n        \n        Args:\n            freq_data (numpy array or pandas series; Hz): the sampling frequency\n            \n            mag_data (numpy array or pandas seres; dB): the magnitude data in decibels\n            \n            phase_data (numpy array or pandas series; deg unwrapped): the phase data in degrees unwrapped\n            \n            ax (matplotlib axis; None): If left None will create a new plot, else must\n                be a matplotlib subplot axis to be added to\n            \n            title (str; ''): Subplot title string\n            \n        Returns:\n            Returns a bode plot, and if an axis was passed to `ax` will be modified\n            with how to plot the magnitude\n            \n        \n        TODO:\n            - figure out how to return the `ax_phase` generated internally\n            - add x,y scale control\n        \"\"\"\n        assert len(freq_data)==len(mag_data)==len(phase_data), 'freq_data, mag_data, phase_data, must all be the same length'\n        \n        if ax!=None:\n            assert repr(type(ax))==\"<class 'matplotlib.axes._subplots.AxesSubplot'>\", 'ax must be a matplotlib axis'\n\n        ax_mag=ax or plt.gca()\n\n\n        #fig, ax_mag=plt.subplots()\n\n        ax_phase=ax_mag.twinx()\n\n        ax_mag.semilogx(freq_data, mag_data, label='mag')\n        ax_phase.semilogx(freq_data, phase_data, color='green', linestyle='--', label='phase')\n        \n\n        ax_mag.set_xlabel('frequancy [Hz]')\n        ax_mag.set_ylabel('[dB]')\n        ax_phase.set_ylabel('[deg]')\n        ax_mag.grid()\n        \n        #make a single legend \n        handles, labels = [(a + b) for a, b in zip(ax_mag.get_legend_handles_labels(), ax_phase.get_legend_handles_labels())]\n        ax_phase.legend(handles, labels)\n\n        if title!='':\n            title=' of '+title\n        ax_mag.set_title(f'Bode Plot{title}')\n        \n        \n        \n    def bode_plot_two_templet(self, freq_data, mag_data, phase_data, \n                              axs=None, title=''):\n        \"\"\"\n        Templet plot to make a Bode plot with Magnitude and Phase in two separate subplots\n        with shared x-axis\n        \n        Args:\n            freq_data (numpy array or pandas series; Hz): the sampling frequency\n            \n            mag_data (numpy array or pandas seres; dB): the magnitude data in decibels\n            \n            phase_data (numpy array or pandas series; deg unwrapped): the phase data in degrees unwrapped\n            \n            axs (list of matplotlib axis; None): If left None will create a new plot, else must \n                be a list of matplotlib subplots axis to be added to where the first entry\n                will be the magnitude axis, and the second will be the phase axis\n            \n            title (str; ''): Subplot title string\n            \n        Returns:\n            Returns a bode plot, and if an axis was passed to `ax` will be modified\n            with how to plot the magnitude\n            \n        \n        TODO:\n            - add x,y scale control\n        \"\"\"\n        \n        assert len(freq_data)==len(mag_data)==len(phase_data), 'freq_data, mag_data, phase_data, must all be the same length'\n        \n       \n        if axs==None:\n            fig, [ax_mag, ax_phase]=plt.subplots(nrows=2, sharex=True)\n        else:\n            assert len(axs)==2, 'there should only be two elements in axs'\n            \n            for i, ax in enumerate(axs):\n                assert repr(type(ax))==\"<class 'matplotlib.axes._subplots.AxesSubplot'>\", f\"element {i} in axs was not a matplotlib axis\"\n            ax_mag=axs[0]; ax_phase=axs[1]\n            ax_mag.get_shared_x_axes().join(ax_mag, ax_phase)\n        \n        #fore the two axes to share x\n        ax_mag.xaxis.set_tick_params(which='both', labelbottom=True)\n\n\n\n\n        ax_mag.semilogx(freq_data, mag_data, label='mag')\n        ax_phase.semilogx(freq_data, phase_data, color='green', linestyle='--', label='phase')\n\n\n\n        ax_mag.set_ylabel('[dB]')\n        ax_phase.set_ylabel('[deg]')\n        ax_mag.grid()\n        ax_phase.grid()\n        \n        #style the x-axis for both subplots so it's between the two\n        ax_phase.set_xlabel('frequancy [Hz]')\n        ax_phase.xaxis.set_label_position('top') \n        ax_phase.xaxis.set_ticks_position('top') \n        ax_phase.tick_params(labelbottom=False,labeltop=True)\n\n        if title!='':\n            title=' of '+title\n        ax_mag.set_title(f'Bode Plot{title}');\n        plt.tight_layout()\n    \n    \n    def nichols_plot_templet(self, mag_data, phase_data, ax=None, title=''):\n        \n        \"\"\"\n        Templet plot to make a Nichols plot with magnitude in the y-axis and\n        phase in the x-axis, with a counter arrow showing the parametric direction\n        \n        Args:\n            \n            mag_data (numpy array or pandas seres; dB): the magnitude data in decibels\n            \n            phase_data (numpy array or pandas series; deg unwrapped): the phase data in degrees unwrapped\n            \n            ax (matplotlib axis; None): If left None will create a new plot, else must\n                be a matplotlib subplot axis to be added to\n            \n            title (str; ''): Subplot title string\n            \n        Returns:\n            Returns a Nichols plot, and if an axis was passed to `ax` will be modified\n            with the Nichols plot\n            \n        \n        TODO:\n            - add x,y scale control\n        \"\"\"\n        \n        assert len(mag_data)==len(phase_data), 'mag_data and phase_data, must all be the same length'\n\n        if ax!=None:\n            assert repr(type(ax))==\"<class 'matplotlib.axes._subplots.AxesSubplot'>\", 'ax must be a matplotlib axis'\n\n        ax=ax or plt.gca()\n\n        ax.plot(phase_data, mag_data)\n        line=ax.get_lines()[0]\n        eecomplex_plot_templets.add_arrow(line)\n\n        \n        #xlim\n        xmin=phase_data.min()*1.1; xmax=phase_data.max()*1.1\n        \n        if -1*xmax<xmin:\n            xmin=-1*xmax\n        \n        if -1*xmin>xmax:\n            xmax=-1*xmin\n            \n        ax.set_xlim(xmin, xmax)\n        \n\n        ax.set_xlabel('[deg]'); ax.set_ylabel('[dB]')\n\n        ax.grid()\n        #ax.axhline(0, linestyle='--', linewidth=2.0, color='black')\n        ax.axvline(0, linestyle='--', linewidth=2.0, color='black')\n        if title!='':\n            title=' of '+title\n        ax.set_title(f'Nichols Plot{title}');\n        \n\n    def nyquist_plot_templet(self, real_data, imag_data, ax=None, title=''):\n        \"\"\"\n        Templet plot to make a Nyquist plot with imaginary in the y-axis and\n        real in the x-axis, with a counter arrow showing the parametric direction\n        \n        Args:\n            \n            real_data (numpy array or pandas series): the real data \n            \n            imag_data (numpy array or pandas series): the imaginary data\n            \n            ax (matplotlib axis; None): If left None will create a new plot, else must\n                be a matplotlib subplot axis to be added to\n            \n            title (str; ''): Subplot title string\n            \n        Returns:\n            Returns a Nyquist plot, and if an axis was passed to `ax` will be modified\n            with the Nyquist plot\n            \n        \n        TODO:\n            - add x,y scale control\n        \"\"\"\n        assert len(real_data)==len(imag_data), 'real_data and imag_data, must all be the same length'\n\n        if ax!=None:\n            assert repr(type(ax))==\"<class 'matplotlib.axes._subplots.AxesSubplot'>\", 'ax must be a matplotlib axis'\n\n        ax=ax or plt.gca()\n\n        ax.plot(real_data, imag_data)\n        line=ax.get_lines()[0]\n        eecomplex_plot_templets.add_arrow(line)\n\n        #xlim\n        xmin=real_data.min()*1.1; xmax=real_data.max()*1.1\n\n        if -1*xmax<xmin:\n            xmin=-1*xmax\n        \n        if -1*xmin>xmax:\n            xmax=-1*xmin\n        ax.set_xlim(xmin, xmax)\n\n        #ylim\n        ymin=imag_data.min()*1.1; ymax=imag_data.max()*1.1\n\n        if -1*ymax<ymin:\n            ymin=-1*ymax\n        \n        if -1*ymin>ymax:\n            ymax=-1*ymin\n        ax.set_ylim(ymin, ymax)\n\n        ax.set_xlabel('Real'); ax.set_ylabel('Imag')\n\n        ax.grid()\n        ax.axhline(0, linestyle='--', linewidth=2.0, color='black')\n        ax.axvline(0, linestyle='--', linewidth=2.0, color='black')\n        if title!='':\n            title=' of '+title\n        ax.set_title(f'Nyquist Plot{title}');\n    \n    @staticmethod\n    def add_arrow(line, positions=None, num_positions=4, direction='right', size=15, color=None):\n        \"\"\"\n        add an arrow to a line axis in the direction of the parametric data.\n\n        line:       Line2D object\n        positions:   list or array of index positions to draw an arrow(s) at; if None will draw at least one arrow\n        num_positions: int; then number arrows to draw along the length of the line; if 1 will draw at the mean\n        direction:  'left' or 'right'\n        size: the size of the arrow in font-size points\n        color:      if None, line color is taken.\n\n        from: https://stackoverflow.com/questions/34017866/arrow-on-a-line-plot-with-matplotlib\n        and also use:https://stackoverflow.com/questions/52042183/matplotlib-get-color-for-subplot\n\n        \n        \"\"\"\n        #if color is None:\n        #    color = line.get_color()\n\n        xdata = line.get_xdata()\n        ydata = line.get_ydata()\n        \n        \n        if (positions is None) and (num_positions==1):\n            positions=[]\n            positions[0] = xdata.mean()\n        elif (positions is None) and (num_positions!=1):\n            line_len=len(xdata)\n            if num_positions>=line_len:\n                num_positions==line_len\n            positions=[xdata[int(np.ceil(i*line_len/num_positions))] for i in range(num_positions)]\n        else:\n            assert all(isinstance(i, int) for i in positions), 'positions must be int index positions'\n        \n        for pos in positions:\n            # find the closest index\n            start_ind = np.argmin(np.absolute(xdata - pos))\n            if direction == 'right':\n                end_ind = start_ind + 1\n            else:\n                end_ind = start_ind - 1\n\n            line.axes.annotate('',\n                xytext=(xdata[start_ind], ydata[start_ind]),\n                xy=(xdata[end_ind], ydata[end_ind]),\n                arrowprops=dict(arrowstyle=\"->\", color=color),\n                size=size\n            )\n\n\n# Here we invoke the class and start by creating the single graph Bode plot with twinx axis so that magnitude and phase are overlapping on one plot\n\n# In[16]:\n\n\nac_p=eecomplex_plot_templets()\n\nac_p.bode_plot_one_templet(ac_rep_tool.ac_sim_mag_DF.index, ac_rep_tool.ac_sim_mag_DF['Out_[V][dB]'], ac_rep_tool.ac_sim_phase_DF['Out_[V][deg]'], \n                          title='Out_[V]')\n\n\n# And here we use the seconed Bode plot method to make the graph with the joined subplots but each subplot has the magnitude and phase respectivly\n\n# In[17]:\n\n\nac_p.bode_plot_two_templet(ac_rep_tool.ac_sim_mag_DF.index, ac_rep_tool.ac_sim_mag_DF['Out_[V][dB]'], ac_rep_tool.ac_sim_phase_DF['Out_[V][deg]'], \n                          title='Out_[V]')\n\n\n# Here is the Nichols plot pf out data with parmteriztion arrows showing the direction of increasing frequancy. Note that since that data was aquared logrimgly and the space inside `eecomplex_plot_templets.add_arrow` uses linear supdivsion the spacing on the arrows is going to follow logrithmicly as well\n\n# In[18]:\n\n\nac_p.nichols_plot_templet(ac_rep_tool.ac_sim_mag_DF['Out_[V][dB]'], ac_rep_tool.ac_sim_phase_DF['Out_[V][deg]'], \n                          title='Out_[V]')\n\n\n# And finally, we create the Nyquist plot again with the same parametricness shown by the arrows and with the same linear to log issue in their spacing.\n\n# In[19]:\n\n\nac_p.nyquist_plot_templet(ac_rep_tool.ac_sim_real_DF['Out_[V]'], ac_rep_tool.ac_sim_imag_DF['Out_[V]'], \n                          title='Out_[V]')\n\n\n# ### A quick filter exploration tool for the rest of this notebook¶\n# \n# Here we create an easy use tool using mutable inheritance of our three ac tools wherein the  `__init__` method it performs the AC simulation, makes the representation transformations, and plot. And in the second method, we get grab the symbolic transfer function for the filter and pass it the same frequencies as the SPICE simulation and plot it on top of the SPICE simulation to examine any mild to gross divergence from the SPICE simulation and the symbolic.\n# \n\n# In[20]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 qfilter_explorer class\n#class to perform the anylsis of the filtes in Ch2 sec 2\n\nclass qfilter_explorer(ac_ease, ac_representation_tool, eecomplex_plot_templets):\n    \n    def __init__(self, circ, title, start_freq=.1@u_Hz, stop_freq=1@u_GHz):\n        \n        #do what ac_ease is supposed to do at startup\n        #instainte the simulation from the circuit\n        ac_ease.__init__(self, circ)\n        #setup the simulation parameter with the helper method\n        self.ac_sweep_setup(start_freq, stop_freq, 20, 'decade', True)\n        #do the simulation\n        self.do_ac_sim()\n        \n        \n        #do what ac_representation_tool is supposed to do at startup\n        #and pass in the selfs from `ac_ease`'s ac_resultsNB_DF\n        ac_representation_tool.__init__(self, self.ac_resultsNB_DF)\n        #generate the representations\n        self.make_real_imag()\n        self.make_mag_phase()\n        \n        \n        eecomplex_plot_templets.__init__(self)\n\n\n        fig=plt.figure(constrained_layout=True, figsize=(8,8))\n        spec=fig.add_gridspec(2,2)\n\n        ax_bode=fig.add_subplot(spec[0, :])\n        self.bode_plot_one_templet(self.ac_sim_mag_DF.index, self.ac_sim_mag_DF['Out_[V][dB]'], self.ac_sim_phase_DF['Out_[V][deg]'], \n                          title='Out_[V]', ax=ax_bode)\n\n        ax_nichols=fig.add_subplot(spec[1, 0])\n        self.nichols_plot_templet(self.ac_sim_mag_DF['Out_[V][dB]'], self.ac_sim_phase_DF['Out_[V][deg]'], \n                          title='Out_[V]', ax=ax_nichols)\n\n        ax_nyquist=fig.add_subplot(spec[1, 1])\n        self.nyquist_plot_templet(self.ac_sim_real_DF['Out_[V]'], self.ac_sim_imag_DF['Out_[V]'], \n                          title='Out_[V]', ax=ax_nyquist)\n        \n        fig.suptitle(title)\n    \n    def symbolic_tf(self, filter_obj):\n        self.symbolic_data=pd.DataFrame(index=self.ac_resultsNB_DF.index)\n        \n        f=self.symbolic_data.index.values\n        \n        #get the tf and get the data\n        tf=filter_obj.get_tf()\n        symbolic_data=tf.frequency_response(self.symbolic_data.index.values).astype('complex')\n        \n        self.symbolic_data['Out_sym_[V][dB]']=20*np.log10(np.abs(symbolic_data))\n        self.symbolic_data['Out_sym_[V][deg]']=np.angle(symbolic_data, deg=True)\n\n        fig, [ax_mag, ax_ph]=plt.subplots(nrows=2, ncols=1)\n        \n        self.bode_plot_two_templet(self.ac_sim_mag_DF.index, self.ac_sim_mag_DF['Out_[V][dB]'], self.ac_sim_phase_DF['Out_[V][deg]'], \n                          title='Simulated vs Symbolic Out_[V]', axs=[ax_mag, ax_ph])\n        \n        #add the symbolic data\n        ax_mag.semilogx(f, self.symbolic_data['Out_sym_[V][dB]'], linestyle='-.' , alpha=0.5, label='symbolic')\n        ax_mag.legend()\n        \n        ax_ph.semilogx(f, self.symbolic_data['Out_sym_[V][deg]'], color='orange' , alpha=0.75, label='symbolic')\n        ax_ph.legend()    \n\n\n# In[21]:\n\n\nfilter_responce=qfilter_explorer(circ, 'RC Low Pass Filter Responce');\n\n\n# In[22]:\n\n\nfilter_responce.symbolic_tf(lowpassF)\n\n\n# ##Equivalent Low Pass RL filter\n# \n# Besides RC filters, there are of course RL dual filters. Where the equivalent RL filter values to any RC filter may be found via the equivalent time constant of the RC and RL implementation such that time constants must match ie: $$RC=\\tau_{RC}=\\tau_{RL}=L/R$$\n\n# In[23]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 rl_lowpass filter class\n#class with lcapy and skidl subcircuit to create an RL lowpass filter\n\nclass rl_lowpass():\n    \"\"\"\n    holding class for SkiDl subcircuit and lcapy schematic of a\n    lowpass RL filter primitive\n    \"\"\"\n    def __init__(self, subcirc_ref=None, L_value=1@u_H, R_value=1@u_Ohm):\n        \"\"\"\n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            L_value (float; 1@u_H; Henery): the inductance in henrys for the RL inductive element\n            R_value (float; 1@u_Ohm; Ohms): the resistance in ohms for the RL resistive element\n\n        Returns:\n            None\n        TODO:\n            -add assertions\n        \"\"\"\n        #add assertions\n        self.subcirc_ref=subcirc_ref\n        self.L_value=L_value\n        self.R_value=R_value\n        \n\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - RL_Lowpass - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RL lowpass filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        \n        if self.subcirc_ref!=None:\n            Lref={'ref':f'L_{self.subcirc_ref}'}\n            Rref={'ref':f'R_{self.subcirc_ref}'}\n        else:\n            Lref={}\n            Rref={}\n        \n        self.l=L(value=self.L_value, **Lref)\n        self.r=R(value=self.R_value, **Rref)\n        \n        self.l['p', 'n']+=term_0, term_2\n        self.r[1, 2]+=self.l['n'], term_1\n        \n        if return_elements:\n            return self.l, self.r\n    \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class filter, extract the transfer function, \n        exstract the 2Port Repersntation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes filter schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - get the Vin statement into the schematic\n        \n        \"\"\"\n        \n        self.schematic=kiwi.Circuit()\n        self.schematic.add('W 1 1_1; right=2')\n        self.schematic.add('W 0 0_1; right')\n        #self.schematic.add('P1 0 1; down, v=V_i')\n        \n        self.schematic.add(f'L 0_1 2_1; right, l=L{str(self.L_value)}')\n        self.schematic.add(f'R 2_1 1_1; down, l=R{str(self.R_value)}')\n        \n        self.schematic.add('W 2_1 2; right=1.5')\n        self.schematic.add('W 1_1 3; right=1.5')\n        self.schematic.add('P2 2 3; down, v=V_o')\n        \n        if with_values:\n            self.schematic=self.schematic.subs({'R':self.R_value, 'L':self.L_value})\n        \n        if draw_me:\n            self.schematic.draw()\n\n    \n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n        \n\n\n# In[24]:\n\n\n#instatate the rl_lowpass filter to \nrl_l=rl_lowpass(L_value=(1e3)**2 *.1e-9 @u_H, R_value=1e3)\nrl_l.lcapy_self()\n\n\n# In[25]:\n\n\n#get this filters abstract transfer function\nrl_l.get_tf(with_values=False)\n\n\n# In[26]:\n\n\n#get this filters transfer function\nrl_l.get_tf(with_values=True)\n\n\n# In[27]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out'); \n\n#create a 1V AC test source and attache to nets\nvs=SINEV(ac_magnitude=1@u_V); vs['p', 'n']+=net_in, gnd\n\n#attaceh term_0 to net_in and term_2 to net_out per scikit-rf convention all \n#other terminals are grounded\nrl_l.SKiDl(net_in, gnd, net_out, gnd)\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In[28]:\n\n\nfilter_responce=qfilter_explorer(circ, 'RL Low Pass Filter Responce');\n\n\n# In[29]:\n\n\nfilter_responce.symbolic_tf(rl_l)\n\n\n# ## The high pass filter from ALL ABOUT ELECTRONICS \"RC High Pass Filter Explained\" @~ 7:57min\n# \n# As we saw with the RC and RL \"Lowpass\" filters they are named by the typical convention of how there implemented followed by some characteristic description of their magnitude response. Thus, lowpass filters minimally attenuate any single whose frequency content is less than the frequency of their 3dB knee. Whereas Highpass filters are the complement to that where they will highly attenuate any single whose frequency content is less than there 3dB knee as shown below using the example from ALL ABOUT ELELECTROINC YT video on “RC High Pass Filters”\n\n# In[30]:\n\n\nYouTubeVideo('9Dx0b0ukNAM', width=500, height=400, start=477)\n\n\n# In[31]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 rc_highpass filter class\n#class with lcapy and skidl subcircuit to create an RC highpass filter\n\nclass rc_highpass():\n    \"\"\"\n    holding class for SkiDl subcircuit and lcapy schematic of a\n    highpass RC filter primitive\n    \"\"\"\n    \n    def __init__(self, subcirc_ref=None, C_value=1@u_F, R_value=1@u_Ohm):\n        \"\"\"\n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            C_value (float; 1@u_F; Farads): the capacitance in farads for the RC capacitive element\n            R_value (float; 1@u_Ohm; Ohms): the resistance in ohms for the RC resistive element\n\n        Returns:\n            None\n        TODO:\n            -add assertions\n        \"\"\"\n        #add assertions\n        self.subcirc_ref=subcirc_ref\n        self.C_value=C_value\n        self.R_value=R_value\n        \n\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - RC_highpass - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RC highpass filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        if self.subcirc_ref!=None:\n            Cref={'ref':f'C_{self.subcirc_ref}'}\n            Rref={'ref':f'R_{self.subcirc_ref}'}\n        else:\n            Cref={}\n            Rref={}\n            \n        self.c=C(value=self.C_value, **Cref)\n        self.r=R(value=self.R_value, **Rref)\n        \n        self.c['p', 'n']+=term_0, term_2\n        self.r[1, 2]+=self.c['n'], term_1\n        \n        if return_elements:\n            return self.c, self.r\n    \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class filter, extract the transfer function, \n        exstract the 2Port Repersntation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes filter schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - get the Vin statement into the schematic\n        \n        \"\"\"\n        \n        self.schematic=kiwi.Circuit()\n        self.schematic.add('W 1 1_1; right=2')\n        self.schematic.add('W 0 0_1; right')\n        #self.schematic.add('P1 0 1; down, v=V_i')\n        \n        self.schematic.add('C 0_1 2_1; right')\n        self.schematic.add('R 2_1 1_1; down')\n        \n        self.schematic.add('W 2_1 2; right=1.5')\n        self.schematic.add('W 1_1 3; right=1.5')\n        self.schematic.add('P2 2 3; down, v=V_o')\n        \n        if with_values:\n            self.schematic=self.schematic.subs({'R':self.R_value, 'C':self.C_value})\n        \n        if draw_me:\n            self.schematic.draw()\n\n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n            \n        \n\n\n# In[32]:\n\n\nhighpassF=rc_highpass(C_value=1.5@u_nF, R_value=10@u_kOhm)\nhighpassF.lcapy_self()\n\n\n# In[33]:\n\n\n#get this filters abstract transfer function\nhighpassF.get_tf(with_values=False)\n\n\n# In[34]:\n\n\n#get this filters transfer function\nhighpassF.get_tf(with_values=True)\n\n\n# In[35]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out'); \n\n#create a 1V AC test source and attache to nets\nvs=SINEV(ac_magnitude=1@u_V); vs['p', 'n']+=net_in, gnd\n\n#attaceh term_0 to net_in and term_2 to net_out per scikit-rf convention all \n#other terminals are grounded\nhighpassF.SKiDl(net_in, gnd, net_out, gnd)\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In[36]:\n\n\nfilter_responce=qfilter_explorer(circ, 'RC High Pass Filter Responce');\n\n\n# In[37]:\n\n\nfilter_responce.symbolic_tf(highpassF)\n\n\n# ## RL Highpass\n\n# In[38]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 rl_highpass filter class\n#class with lcapy and skidl subcircuit to create an RL highpass filter\n\nclass rl_highpass():\n    \"\"\"\n    holding class for SkiDl subcircuit and lcapy schematic of a\n    highpass RL filter primitive\n    \"\"\"\n    \n    def __init__(self, subcirc_ref=None, L_value=1@u_H, R_value=1@u_Ohm):\n        \"\"\"\n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            L_value (float; 1@u_F; Henerys): the inductance in farads for the RL inductive element\n            R_value (float; 1@u_Ohm; Ohms): the resistance in ohms for the RL resistive element\n\n        Returns:\n            None\n        TODO:\n            -add assertions\n        \"\"\"\n        #add assertions\n        self.subcirc_ref=subcirc_ref\n        self.L_value=L_value\n        self.R_value=R_value\n        \n\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - RL_highpass - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RL highpass filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        if self.subcirc_ref!=None:\n            Lref={'ref':f'L_{self.subcirc_ref}'}\n            Rref={'ref':f'R_{self.subcirc_ref}'}\n        else:\n            Lref={}\n            Rref={}\n        \n        self.l=L(value=self.L_value, **Lref)\n        self.r=R(value=self.R_value, **Rref)\n        \n        self.r[1, 2]+=term_0, self.l['p']\n        self.l['p', 'n']+=term_2, term_3\n        \n        \n        \n        \n        if return_elements:\n            return self.l, self.r\n    \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class filter, extract the transfer function, \n        exstract the 2Port Repersntation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes filter schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - get the Vin statement into the schematic\n        \n        \"\"\"\n        \n        self.schematic=kiwi.Circuit()\n        self.schematic.add('W 1 1_1; right=2')\n        self.schematic.add('W 0 0_1; right')\n        #self.schematic.add('P1 0 1; down, v=V_i')\n        \n        self.schematic.add(f'R 0_1 2_1; right')\n        self.schematic.add(f'L 2_1 1_1; down')\n        \n        self.schematic.add('W 2_1 2; right=1.5')\n        self.schematic.add('W 1_1 3; right=1.5')\n        self.schematic.add('P2 2 3; down, v=V_o')\n\n        \n        if with_values:\n            self.schematic=self.schematic.subs({'R':self.R_value, 'L':self.L_value})\n        \n        if draw_me:\n            self.schematic.draw()\n    \n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n        \n            \n\n\n# In[39]:\n\n\nrl_h=rl_highpass(L_value=(10e3)**2 *1.5e-9 @u_H, R_value=10@u_kOhm)\nrl_h.lcapy_self()\n\n\n# In[40]:\n\n\n#get this filters abstract transfer function\nrl_h.get_tf(with_values=False)\n\n\n# In[41]:\n\n\n#get this filters transfer function\nrl_h.get_tf(with_values=True)\n\n\n# In[42]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out'); \n\n#create a 1V AC test source and attache to nets\nvs=SINEV(ac_magnitude=1@u_V); vs['p', 'n']+=net_in, gnd\n\n#attaceh term_0 to net_in and term_2 to net_out per scikit-rf convention all \n#other terminals are grounded\nrl_h.SKiDl(net_in, gnd, net_out, gnd)\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In[43]:\n\n\nfilter_responce=qfilter_explorer(circ, 'RL High Pass Filter Responce');\n\n\n# In[44]:\n\n\nfilter_responce.symbolic_tf(rl_h)\n\n\n# # First Order Cascade filter\n\n# Though as we will see there are more complex single filter designs that can implement a needed filter profile the other way to implement the needed filter profile is by cascading primitive filter sections as shown by ALL ABOUT ELELECTOINCS where here we will just implement the passive version of the cascaded bandpass filter shown below.\n\n# ## The band pass filter from ALL ABOUT ELECTRONICS \"Band Pass Filter and Band Stop Filter Explained\" @~ 4:03min\n\n# In[45]:\n\n\nYouTubeVideo('dmPIydL0lyM', width=500, height=400, start=243)\n\n\n# In[46]:\n\n\nreset()\nnet_in=Net('In'); net_inter=Net('Inter'); net_out=Net('Out')\n\nvs=SINEV(amplitude=10@u_V, frequency=10@u_kHz)\nvs['p', 'n']+=net_in, gnd\n\nhighpassFsection=rc_highpass(C_value=1.5@u_nF, R_value=10@u_kOhm)\nhighpassFsection.SKiDl(net_in, gnd, net_inter, gnd)\n\nlowpassFsection=rc_lowpass(C_value=1.5@u_nF, R_value=1@u_kOhm)\nlowpassFsection.SKiDl(net_inter, gnd, net_out, gnd)\n\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In[47]:\n\n\nfilter_responce=qfilter_explorer(circ, 'RC Band pass Filter Responce');\n\n\n# Becouse this is a cascaded filter to get the symbolic filter we need to casade them where for a recap of how to cascade filters in all the varies toplogies see https://x-engineer.org/graduate-engineering/signals-systems/control-systems/transfer-function-algebra/\n\n# In[48]:\n\n\ncascade_tf=highpassFsection.get_tf() * lowpassFsection.get_tf() \nsym.sympify(cascade_tf)\n\n\n# And so for the sake of simplicity we will just reimpliment `qfilter_explorer.symbolic_tf` manulay here to compare the casdacded symbolic trnasfer fuction to the SPICE simulated results\n\n# In[49]:\n\n\nsymbolic_data=pd.DataFrame(index=filter_responce.ac_resultsNB_DF.index)\nf=symbolic_data.index.values\n\n##bring the f through the sausage filter\nsymbolic_data_raw=cascade_tf.frequency_response(f).astype('complex')\n\nsymbolic_data['Out_sym_[V][dB]']=20*np.log10(np.abs(symbolic_data_raw))\nsymbolic_data['Out_sym_[V][deg]']=np.angle(symbolic_data_raw, deg=True)\n\nfig, [ax_mag, ax_ph]=plt.subplots(nrows=2, ncols=1)\n\nacplot=eecomplex_plot_templets()\nacplot.bode_plot_two_templet(filter_responce.ac_sim_mag_DF.index, filter_responce.ac_sim_mag_DF['Out_[V][dB]'], filter_responce.ac_sim_phase_DF['Out_[V][deg]'], \n                  title='Simulated vs Symbolic Out_[V]', axs=[ax_mag, ax_ph])\n\n#add the symbolic data\nax_mag.semilogx(f, symbolic_data['Out_sym_[V][dB]'], linestyle='-.' , alpha=0.5, label='symbolic')\nax_mag.legend()\n\nax_ph.semilogx(f, symbolic_data['Out_sym_[V][deg]'], color='orange' , alpha=0.75, label='symbolic')\nax_ph.legend();\n\n\n# # Second-Order Filters and resonators\n# Second-order filters are mostly designed around the following equations in their circuit implementation \n# \n# - Bandwidth ($B$):$B=\\omega_2-\\omega_1$\n# - Center Frequncy ($\\omega_0$): $\\omega_0=\\dfrac{1}{\\sqrt{LC}}=\\sqrt{\\omega_1 \\omega_2}$\n# - The Q Factor in general: $Q=\\dfrac{\\omega_0}{B}$\n#     - Q for a series RLC is: $Q=\\dfrac{1}{\\omega_0 RC}$\n#     - Q for a parrel RLC is: $Q=\\omega_0 RC$\n#  \n#  \tAnd are called second-order since with having both a Capacitor and Inductor the differential equations in the time domain become second order. Below we will implement the four main second-order filter types: Lowpass, Highpass, Bandpass, Bandstop, in both their series and parral configurations. Where the templet around the values for the RLC elements used for these filters is the bandwidth frequencies of the ALL ABOUT CIRCUITS example of a passive cascaded filter above using a 50Ohm resistor, because.\n\n# ## Series Based¶\n\n# In[50]:\n\n\nV_out, V_in, angfreq_1, angfreq_2, angfreq_0, R_sym, C_sym, L_sym, Q_sym, f_sym, f0_sym, B_sym=sym.symbols('V_{out}, V_{in}, omega_1, omega_2, omega_0, R, C, L, Q, f, f_0, B' )\nV_out, V_in, angfreq_1, angfreq_2, angfreq_0, R_sym, C_sym, L_sym, Q_sym, f_sym, f0_sym, B_sym\n\n\n# In[51]:\n\n\nf1=10.61e3; f2=106.1e3\nsubs={R_sym:50}\nsubs[angfreq_1]=2*np.pi*f1; subs[angfreq_2]=2*np.pi*f2\nsubs[angfreq_0]=np.sqrt(subs[angfreq_1]*subs[angfreq_2])\nsubs[B_sym]=subs[angfreq_2]-subs[angfreq_1]\nsubs[Q_sym]=subs[angfreq_0]/subs[B_sym]\nsubs\n\n\n# In[52]:\n\n\nQs_eq=sym.Eq(Q_sym, 1/(angfreq_0*R_sym*C_sym)); Qs_eq\n\n\n# In[53]:\n\n\nsubs[C_sym]=sym.solve(Qs_eq, C_sym)[0].subs(subs); subs\n\n\n# In[54]:\n\n\nangfreq_0_eq=sym.Eq(angfreq_0, 1/sym.sqrt(L_sym*C_sym)); angfreq_0_eq\n\n\n# In[55]:\n\n\nsubs[L_sym]=sym.solve(angfreq_0_eq, L_sym)[0].subs(subs); subs\n\n\n# ### RLC series lowpass\n\n# In[56]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 rlc_series_lowpass filter class\n#class with lcapy and skidl subcircuit to create an RLC series lowpass filter\n\nclass rlc_series_lowpass():\n    \"\"\"\n    holding class for SkiDl subcircuit and lcapy schematic of a\n    lowpass series RLC filter primitive\n    \"\"\"\n    \n    def __init__(self, subcirc_ref=None, L_value=1@u_H, C_value=1@u_F, R_value=1@u_Ohm):\n        \"\"\"\n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            L_value (float; 1@u_F; Henerys): the inductance in farads for the RLC inductive element\n            C_value (float; 1@u_F; Farads): the capacitance in farads for the RLC capacitive element\n            R_value (float; 1@u_Ohm; Ohms): the resistance in ohms for the RLC resistive element\n\n        Returns:\n            None\n        TODO:\n            -add assertions\n        \"\"\"\n        #add assertions\n        self.subcirc_ref=subcirc_ref\n        self.L_value=L_value\n        self.C_value=C_value\n        self.R_value=R_value\n        \n\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - RLC_s_Lowpass - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RLC series lowpass filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        if self.subcirc_ref!=None:\n            Lref={'ref':f'L_{self.subcirc_ref}'}\n            Cref={'ref':f'C_{self.subcirc_ref}'}\n            Rref={'ref':f'R_{self.subcirc_ref}'}\n        else:\n            Lref={}\n            Cref={}\n            Rref={}\n        \n        self.l=L(value=self.L_value, **Lref)\n        self.c=C(value=self.C_value, **Cref)\n        self.r=R(value=self.R_value, **Rref)\n        \n        self.r[1, 2]+=term_0, self.l[1]\n        self.l[2]+=term_2, self.c['p']\n        self.c['n']+=term_1, term_3\n        \n        \n        if return_elements:\n            return self.c, self.r, self.l\n    \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class filter, extract the transfer function, \n        exstract the 2Port Repersntation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes filter schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - get the Vin statement into the schematic\n        \n        \"\"\"\n        \n        \n        self.schematic=kiwi.Circuit()\n        self.schematic.add('W 0 0_1; right')\n        self.schematic.add('W 1 1_1; right=3')\n        #self.schematic.add('P1 0 1; down, v=V_i')\n        \n        self.schematic.add('R 0_1 N1; right')\n        self.schematic.add('L N1 2_1; right')\n        self.schematic.add('C 2_1 1_1; down')\n        \n        self.schematic.add('W 2_1 2; right=1.5')\n        self.schematic.add('W 1_1 3; right=1.5')\n        self.schematic.add('P2 2 3; down, v=V_o')\n\n        \n        if with_values:\n            self.schematic=self.schematic.subs({'R':self.R_value, 'L':self.L_value, 'C':self.C_value})\n        \n        if draw_me:\n            self.schematic.draw()\n    \n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n\n\n# In[57]:\n\n\n#instatate the rlc_lowpass filter \nlowpassRLC_s=rlc_series_lowpass(L_value=8.33e-5@u_H, C_value=2.7e-7@u_F, R_value=50@u_Ohm)\nlowpassRLC_s.lcapy_self()\n\n\n# In[58]:\n\n\n#get this filters abstract transfer function\nlowpassRLC_s.get_tf(with_values=False)\n\n\n# In[59]:\n\n\n#get this filters transfer function\nlowpassRLC_s.get_tf(with_values=True)\n\n\n# In[60]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out'); \n\n#create a 1V AC test source and attache to nets\nvs=SINEV(ac_magnitude=1@u_V); vs['p', 'n']+=net_in, gnd\n\n#attaceh term_0 to net_in and term_2 to net_out per scikit-rf convention all \n#other terminals are grounded\nlowpassRLC_s.SKiDl(net_in, gnd, net_out, gnd)\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In[61]:\n\n\nfilter_responce=qfilter_explorer(circ, 'RLC Series Lowpass Filter Responce');\n\n\n# In[62]:\n\n\nfilter_responce.symbolic_tf(lowpassRLC_s)\n\n\n# ### RLC series highpass\n\n# In[63]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 rlc_series_highpass filter class\n#class with lcapy and skidl subcircuit to create an RLC series highpass filter\n\nclass rlc_series_highpass():\n    \"\"\"\n    holding class for SkiDl subcircuit and lcapy schematic of a\n    highpass series RLC filter primitive\n    \"\"\"\n    \n    def __init__(self, subcirc_ref=None, L_value=1@u_H, C_value=1@u_F, R_value=1@u_Ohm):\n        \"\"\"\n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            L_value (float; 1@u_F; Henerys): the inductance in farads for the RLC inductive element\n            C_value (float; 1@u_F; Farads): the capacitance in farads for the RLC capacitive element\n            R_value (float; 1@u_Ohm; Ohms): the resistance in ohms for the RLC resistive element\n\n        Returns:\n            None\n        TODO:\n            -add assertions\n        \"\"\"\n        #add assertions\n        self.subcirc_ref=subcirc_ref\n        self.L_value=L_value\n        self.C_value=C_value\n        self.R_value=R_value\n        \n\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - RLC_s_highpass - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RLC series highpass filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        if self.subcirc_ref!=None:\n            Lref={'ref':f'L_{self.subcirc_ref}'}\n            Cref={'ref':f'C_{self.subcirc_ref}'}\n            Rref={'ref':f'R_{self.subcirc_ref}'}\n        else:\n            Lref={}\n            Cref={}\n            Rref={}\n        \n        self.l=L(value=self.L_value, **Lref)\n        self.c=C(value=self.C_value, **Cref)\n        self.r=R(value=self.R_value, **Rref)\n        \n        self.r[1, 2]+=term_0, self.c['p']\n        self.c['n']+=term_2, self.l[1]\n        self.l[2]+=term_1, term_3\n        \n        \n        if return_elements:\n            return self.c, self.r, self.l\n    \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class filter, extract the transfer function, \n        exstract the 2Port Repersntation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes filter schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - get the Vin statement into the schematic\n        \n        \"\"\"\n        \n        self.schematic=kiwi.Circuit()\n        self.schematic.add('W 0 0_1; right')\n        self.schematic.add('W 1 1_1; right=3')\n        #self.schematic.add('P1 0 1; down, v=V_i')\n        \n        self.schematic.add(f'R 0_1 N1; right')\n        self.schematic.add(f'C N1 2_1; right')\n        self.schematic.add(f'L 2_1 1_1; down')\n        \n        self.schematic.add('W 2_1 2; right=1.5')\n        self.schematic.add('W 1_1 3; right=1.5')\n        self.schematic.add('P2 2 3; down, v=V_o')\n        \n        if with_values:\n            self.schematic=self.schematic.subs({'R':self.R_value, 'L':self.L_value, 'C':self.C_value})\n        \n        if draw_me:\n            self.schematic.draw()\n    \n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n\n\n# In[64]:\n\n\n#instatate the rlc_highpass filter  \nhighpassRLC_s=rlc_series_highpass(L_value=8.33e-5@u_H, C_value=2.7e-7@u_F, R_value=50@u_Ohm)\nhighpassRLC_s.lcapy_self()\n\n\n# In[65]:\n\n\n#get this filters abstract transfer function\nhighpassRLC_s.get_tf(with_values=False)\n\n\n# In[66]:\n\n\n#get this filters transfer function\nhighpassRLC_s.get_tf(with_values=True)\n\n\n# In[67]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out'); \n\n#create a 1V AC test source and attache to nets\nvs=SINEV(ac_magnitude=1@u_V); vs['p', 'n']+=net_in, gnd\n\n#attaceh term_0 to net_in and term_2 to net_out per scikit-rf convention all \n#other terminals are grounded\nhighpassRLC_s.SKiDl(net_in, gnd, net_out, gnd)\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In[68]:\n\n\nfilter_responce=qfilter_explorer(circ, 'RLC Series Lowpass Filter Responce');\n\n\n# In[69]:\n\n\nfilter_responce.symbolic_tf(highpassRLC_s)\n\n\n# ### RLC series bandpass\n\n# In[70]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 rlc_series_bandpass filter class\n#class with lcapy and skidl subcircuit to create an RLC series bandpass filter\n\nclass rlc_series_bandpass():\n    \"\"\"\n    holding class for SkiDl subcircuit and lcapy schematic of a\n    bandpass series RLC filter primitive\n    \"\"\"\n    \n    def __init__(self, subcirc_ref=None, L_value=1@u_H, C_value=1@u_F, R_value=1@u_Ohm):\n        \"\"\"\n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            L_value (float; 1@u_F; Henerys): the inductance in farads for the RLC inductive element\n            C_value (float; 1@u_F; Farads): the capacitance in farads for the RLC capacitive element\n            R_value (float; 1@u_Ohm; Ohms): the resistance in ohms for the RLC resistive element\n\n        Returns:\n            None\n        TODO:\n            -add assertions\n        \"\"\"\n        #add assertions\n        self.subcirc_ref=subcirc_ref\n        self.L_value=L_value\n        self.C_value=C_value\n        self.R_value=R_value\n        \n\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - RLC_s_bandpass - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RLC series bandpass filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        if self.subcirc_ref!=None:\n            Lref={'ref':f'L_{self.subcirc_ref}'}\n            Cref={'ref':f'C_{self.subcirc_ref}'}\n            Rref={'ref':f'R_{self.subcirc_ref}'}\n        else:\n            Lref={}\n            Cref={}\n            Rref={}\n        \n        self.l=L(value=self.L_value, **Lref)\n        self.c=C(value=self.C_value, **Cref)\n        self.r=R(value=self.R_value, **Rref)\n        \n        self.l[1, 2]+=term_0, self.c['p']\n        self.c['n']+=term_2, self.r[1]\n        self.r[2]+=term_1, term_3\n        \n        \n        if return_elements:\n            return self.c, self.r, self.l\n    \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class filter, extract the transfer function, \n        exstract the 2Port Repersntation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes filter schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - get the Vin statement into the schematic\n        \n        \"\"\"\n        \n        self.schematic=kiwi.Circuit()\n        self.schematic.add('W 0 0_1; right')\n        self.schematic.add('W 1 1_1; right=3')\n        #self.schematic.add('P1 0 1; down, v=V_i')\n        \n        self.schematic.add(f'L 0_1 N1; right')\n        self.schematic.add(f'C N1 2_1; right')\n        self.schematic.add(f'R 2_1 1_1; down')\n        \n       \n        self.schematic.add('W 2_1 2; right=1.5')\n        self.schematic.add('W 1_1 3; right=1.5')\n        self.schematic.add('P2 2 3; down, v=V_o')\n        \n        if with_values:\n            self.schematic=self.schematic.subs({'R':self.R_value, 'L':self.L_value, 'C':self.C_value})\n        \n        if draw_me:\n            self.schematic.draw()\n    \n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n\n\n# In[71]:\n\n\n#instatate the rlc_bandpass filter  \nbandpassRLC_s=rlc_series_bandpass(L_value=8.33e-5@u_H, C_value=2.7e-7@u_F, R_value=50@u_Ohm)\nbandpassRLC_s.lcapy_self()\n\n\n# In[72]:\n\n\n#get this filters abstract transfer function\nbandpassRLC_s.get_tf(with_values=False)\n\n\n# In[73]:\n\n\n#get this filters transfer function\nbandpassRLC_s.get_tf(with_values=True)\n\n\n# In[74]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out'); \n\n#create a 1V AC test source and attache to nets\nvs=SINEV(ac_magnitude=1@u_V); vs['p', 'n']+=net_in, gnd\n\n#attaceh term_0 to net_in and term_2 to net_out per scikit-rf convention all \n#other terminals are grounded\nbandpassRLC_s.SKiDl(net_in, gnd, net_out, gnd)\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In[75]:\n\n\nfilter_responce=qfilter_explorer(circ, 'RLC Series Bandpass Filter Responce');\n\n\n# In[76]:\n\n\nfilter_responce.symbolic_tf(bandpassRLC_s)\n\n\n# ### RLC series bandstop\n\n# In[77]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 rlc_series_bandstop filter class\n#class with lcapy and skidl subcircuit to create an RLC series bandstop filter\n\nclass rlc_series_bandstop():\n    \"\"\"\n    holding class for SkiDl subcircuit and lcapy schematic of a\n    bandstop series RLC filter primitive\n    \"\"\"\n    \n    def __init__(self, subcirc_ref=None, L_value=1@u_H, C_value=1@u_F, R_value=1@u_Ohm):\n        \"\"\"\n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            L_value (float; 1@u_F; Henerys): the inductance in farads for the RLC inductive element\n            C_value (float; 1@u_F; Farads): the capacitance in farads for the RLC capacitive element\n            R_value (float; 1@u_Ohm; Ohms): the resistance in ohms for the RLC resistive element\n\n        Returns:\n            None\n        TODO:\n            -add assertions\n        \"\"\"\n        #add assertions\n        self.subcirc_ref=subcirc_ref\n        self.L_value=L_value\n        self.C_value=C_value\n        self.R_value=R_value\n        \n\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - RLC_s_bandstop - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RLC series bandstop filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        if self.subcirc_ref!=None:\n            Lref={'ref':f'L_{self.subcirc_ref}'}\n            Cref={'ref':f'C_{self.subcirc_ref}'}\n            Rref={'ref':f'R_{self.subcirc_ref}'}\n        else:\n            Lref={}\n            Cref={}\n            Rref={}\n        \n        self.l=L(value=self.L_value, **Lref)\n        self.c=C(value=self.C_value, **Cref)\n        self.r=R(value=self.R_value, **Rref)\n        \n        self.r[1, 2]+=term_0, term_2\n        self.l[1, 2]+=self.r[2], self.c['p']\n        self.c['n']+=term_1, term_3\n        \n        \n        if return_elements:\n            return self.c, self.r, self.l\n    \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class filter, extract the transfer function, \n        exstract the 2Port Repersntation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes filter schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - get the Vin statement into the schematic\n        \n        \"\"\"\n        \n        self.schematic=kiwi.Circuit()\n        self.schematic.add('W 0 0_1; right')\n        self.schematic.add('W 1 1_1; right=2')\n        #self.schematic.add('P1 0 1; down, v=V_i')\n        \n        self.schematic.add(f'R 0_1 2_1; right')\n        self.schematic.add(f'L 2_1 N1; down')\n        self.schematic.add(f'C N1 1_1; down')\n        \n       \n        self.schematic.add('W 2_1 2; right=1.5')\n        self.schematic.add('W 1_1 3; right=1.5')\n        self.schematic.add('P2 2 3; down, v=V_o')\n        \n        if with_values:\n            self.schematic=self.schematic.subs({'R':self.R_value, 'L':self.L_value, 'C':self.C_value})\n        \n        if draw_me:\n            self.schematic.draw()\n    \n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n\n\n# In[78]:\n\n\n#instatate the rlc_bandstop filter\nbandstopRLC_s=rlc_series_bandstop(L_value=8.33e-5@u_H, C_value=2.7e-7@u_F, R_value=50@u_Ohm)\nbandstopRLC_s.lcapy_self()\n\n\n# In[79]:\n\n\n#get this filters abstract transfer function\nbandstopRLC_s.get_tf(with_values=False)\n\n\n# In[80]:\n\n\n#get this filters transfer function\nbandstopRLC_s.get_tf(with_values=True)\n\n\n# In[81]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out'); \n\n#create a 1V AC test source and attache to nets\nvs=SINEV(ac_magnitude=1@u_V); vs['p', 'n']+=net_in, gnd\n\n#attaceh term_0 to net_in and term_2 to net_out per scikit-rf convention all \n#other terminals are grounded\nbandstopRLC_s.SKiDl(net_in, gnd, net_out, gnd)\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In[82]:\n\n\nfilter_responce=qfilter_explorer(circ, 'RLC Series Bandstop Filter Responce');\n\n\n# In[83]:\n\n\nfilter_responce.symbolic_tf(bandstopRLC_s)\n\n\n# ## Parallel Based¶\n\n# In[84]:\n\n\nV_out, V_in, angfreq_1, angfreq_2, angfreq_0, R_sym, C_sym, L_sym, Q_sym, f_sym, f0_sym, B_sym=sym.symbols('V_{out}, V_{in}, omega_1, omega_2, omega_0, R, C, L, Q, f, f_0, B' )\nV_out, V_in, angfreq_1, angfreq_2, angfreq_0, R_sym, C_sym, L_sym, Q_sym, f_sym, f0_sym, B_sym\n\n\n# In[85]:\n\n\nf1=10.61e3; f2=106.1e3\nsubs={R_sym:50}\nsubs[angfreq_1]=2*np.pi*f1; subs[angfreq_2]=2*np.pi*f2\nsubs[angfreq_0]=np.sqrt(subs[angfreq_1]*subs[angfreq_2])\nsubs[B_sym]=subs[angfreq_2]-subs[angfreq_1]\nsubs[Q_sym]=subs[angfreq_0]/subs[B_sym]\nsubs\n\n\n# In[86]:\n\n\nQp_eq=sym.Eq(Q_sym, angfreq_0*R_sym*C_sym); Qp_eq\n\n\n# In[87]:\n\n\nsubs[C_sym]=sym.solve(Qp_eq, C_sym)[0].subs(subs); subs\n\n\n# In[88]:\n\n\nangfreq_0_eq=sym.Eq(angfreq_0, 1/sym.sqrt(L_sym*C_sym)); angfreq_0_eq\n\n\n# In[89]:\n\n\nsubs[L_sym]=sym.solve(angfreq_0_eq, L_sym)[0].subs(subs); subs\n\n\n# ### RLC parallel lowpass \n\n# In[90]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 rlc_parallel_lowpass filter class\n#class with lcapy and skidl subcircuit to create an RLC parallel lowpass filter\n\nclass rlc_parallel_lowpass():\n    \"\"\"\n    holding class for SkiDl subcircuit and lcapy schematic of a\n    lowpass parallel RLC filter primitive\n    \"\"\"\n    \n    def __init__(self, subcirc_ref=None, L_value=1@u_H, C_value=1@u_F, R_value=1@u_Ohm):\n        \"\"\"\n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            L_value (float; 1@u_F; Henerys): the inductance in farads for the RLC inductive element\n            C_value (float; 1@u_F; Farads): the capacitance in farads for the RLC capacitive element\n            R_value (float; 1@u_Ohm; Ohms): the resistance in ohms for the RLC resistive element\n\n        Returns:\n            None\n        TODO:\n            -add assertions\n        \"\"\"\n        #add assertions\n        self.subcirc_ref=subcirc_ref\n        self.L_value=L_value\n        self.C_value=C_value\n        self.R_value=R_value\n        \n\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - RLC_s_Lowpass - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RLC parallel lowpass filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        if self.subcirc_ref!=None:\n            Lref={'ref':f'L_{self.subcirc_ref}'}\n            Cref={'ref':f'C_{self.subcirc_ref}'}\n            Rref={'ref':f'R_{self.subcirc_ref}'}\n        else:\n            Lref={}\n            Cref={}\n            Rref={}\n        \n        self.l=L(value=self.L_value, **Lref)\n        self.c=C(value=self.C_value, **Cref)\n        self.r=R(value=self.R_value, **Rref)\n        \n        self.l[1, 2]+=term_0, term_2\n        self.c['p', 'n']+=term_2, term_1\n        self.r[1, 2]+=term_2, term_3\n        self.c['n']+=self.r[2]\n        \n        \n        \n        if return_elements:\n            return self.c, self.r, self.l\n    \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class filter, extract the transfer function, \n        exstract the 2Port Repersntation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes filter schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - get the Vin statement into the schematic\n        \n        \"\"\"\n        \n        self.schematic=kiwi.Circuit()\n        self.schematic.add('W 0 0_1; right')\n        self.schematic.add('W 1 1_1; right=2')\n        #self.schematic.add('P1 0 1; down, v=V_i')\n        \n        self.schematic.add(f'L 0_1 2_2; right')\n        self.schematic.add(f'C 2_2 1_1; down')\n        self.schematic.add('W 2_2 2_1; right')\n        self.schematic.add('W 1_1 3_1; right')\n        self.schematic.add(f'R 2_1 3_1; down')\n\n       \n        self.schematic.add('W 2_1 2; right=1.5')\n        self.schematic.add('W 3_1 3; right=1.5')\n        self.schematic.add('P2 2 3; down, v=V_o')\n        \n        if with_values:\n            self.schematic=self.schematic.subs({'R':self.R_value, 'L':self.L_value, 'C':self.C_value})\n        \n        if draw_me:\n            self.schematic.draw()\n    \n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n\n\n# In[91]:\n\n\n#instatate the rlc_lowpass filter  \nlowpassRLC_p=rlc_parallel_lowpass(L_value=.0006750@u_H, C_value=3.33e-8@u_F, R_value=50@u_Ohm)\nlowpassRLC_p.lcapy_self()\n\n\n# In[92]:\n\n\n#get this filters abstract transfer function\nlowpassRLC_p.get_tf(with_values=False)\n\n\n# In[93]:\n\n\n#get this filters transfer function\nlowpassRLC_p.get_tf(with_values=True)\n\n\n# In[94]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out'); \n\n#create a 1V AC test source and attache to nets\nvs=SINEV(ac_magnitude=1@u_V); vs['p', 'n']+=net_in, gnd\n\n#attaceh term_0 to net_in and term_2 to net_out per scikit-rf convention all \n#other terminals are grounded\nlowpassRLC_p.SKiDl(net_in, gnd, net_out, gnd)\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In[95]:\n\n\nfilter_responce=qfilter_explorer(circ, 'RLC Parallel Lowpass Filter Responce');\n\n\n# In[96]:\n\n\nfilter_responce.symbolic_tf(lowpassRLC_p)\n\n\n# ### RLC parallel highpass \n\n# In[97]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 rlc_parallel_highpass filter class\n#class with lcapy and skidl subcircuit to create an RLC parallel highpass filter\n\nclass rlc_parallel_highpass():\n    \"\"\"\n    holding class for SkiDl subcircuit and lcapy schematic of a\n    highpass parallel RLC filter primitive\n    \"\"\"\n    \n    def __init__(self, subcirc_ref=None, L_value=1@u_H, C_value=1@u_F, R_value=1@u_Ohm):\n        \"\"\"\n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            L_value (float; 1@u_F; Henerys): the inductance in farads for the RLC inductive element\n            C_value (float; 1@u_F; Farads): the capacitance in farads for the RLC capacitive element\n            R_value (float; 1@u_Ohm; Ohms): the resistance in ohms for the RLC resistive element\n\n        Returns:\n            None\n        TODO:\n            -add assertions\n        \"\"\"\n        #add assertions\n        self.subcirc_ref=subcirc_ref\n        self.L_value=L_value\n        self.C_value=C_value\n        self.R_value=R_value\n        \n\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - RLC_s_highpass - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RLC parallel highpass filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        if self.subcirc_ref!=None:\n            Lref={'ref':f'L_{self.subcirc_ref}'}\n            Cref={'ref':f'C_{self.subcirc_ref}'}\n            Rref={'ref':f'R_{self.subcirc_ref}'}\n        else:\n            Lref={}\n            Cref={}\n            Rref={}\n        \n        self.l=L(value=self.L_value, **Lref)\n        self.c=C(value=self.C_value, **Cref)\n        self.r=R(value=self.R_value, **Rref)\n        \n        self.c['p', 'n']+=term_0, term_2\n        self.r[1, 2]+=term_2, term_1\n        self.l[1, 2]+=term_2, term_3\n        self.l[2]+=self.r[2]\n        \n        \n        \n        if return_elements:\n            return self.c, self.r, self.l\n    \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class filter, extract the transfer function, \n        exstract the 2Port Repersntation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes filter schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - get the Vin statement into the schematic\n        \n        \"\"\"\n        \n        self.schematic=kiwi.Circuit()\n        self.schematic.add('W 0 0_1; right')\n        self.schematic.add('W 1 1_1; right=2')\n        #self.schematic.add('P1 0 1; down, v=V_i')\n        \n        self.schematic.add(f'C 0_1 2_2; right')\n        self.schematic.add(f'R 2_2 1_1; down')\n        self.schematic.add('W 2_2 2_1; right')\n        self.schematic.add('W 1_1 3_1; right')\n        self.schematic.add(f'L 2_1 3_1; down')\n        \n        self.schematic.add('W 2_1 2; right=1.5')\n        self.schematic.add('W 3_1 3; right=1.5')\n        self.schematic.add('P2 2 3; down, v=V_o')\n        \n        if with_values:\n            self.schematic=self.schematic.subs({'R':self.R_value, 'L':self.L_value, 'C':self.C_value})\n        \n        if draw_me:\n            self.schematic.draw()\n    \n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n\n\n# In[98]:\n\n\n#instatate the rlc_highpass filter\nhighpassRLC_p=rlc_parallel_highpass(L_value=.0006750@u_H, C_value=3.33e-8@u_F, R_value=50@u_Ohm)\nhighpassRLC_p.lcapy_self()\n\n\n# In[99]:\n\n\n#get this filters abstract transfer function\nhighpassRLC_p.get_tf(with_values=False)\n\n\n# In[100]:\n\n\n#get this filters transfer function\nhighpassRLC_p.get_tf(with_values=True)\n\n\n# In[101]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out'); \n\n#create a 1V AC test source and attache to nets\nvs=SINEV(ac_magnitude=1@u_V); vs['p', 'n']+=net_in, gnd\n\n#attaceh term_0 to net_in and term_2 to net_out per scikit-rf convention all \n#other terminals are grounded\nhighpassRLC_p.SKiDl(net_in, gnd, net_out, gnd)\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In[102]:\n\n\nfilter_responce=qfilter_explorer(circ, 'RLC Parallel Highpass Filter Responce');\n\n\n# In[103]:\n\n\nfilter_responce.symbolic_tf(highpassRLC_p)\n\n\n# ### RLC parallel bandpass \n\n# In[104]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 rlc_parallel_bandpass filter class\n#class with lcapy and skidl subcircuit to create an RLC parallel bandpass filter\n\nclass rlc_parallel_bandpass():\n    \"\"\"\n    holding class for SkiDl subcircuit and lcapy schematic of a\n    bandpass parallel RLC filter primitive\n    \"\"\"\n    \n    def __init__(self, subcirc_ref=None, L_value=1@u_H, C_value=1@u_F, R_value=1@u_Ohm):\n        \"\"\"\n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            L_value (float; 1@u_F; Henerys): the inductance in farads for the RLC inductive element\n            C_value (float; 1@u_F; Farads): the capacitance in farads for the RLC capacitive element\n            R_value (float; 1@u_Ohm; Ohms): the resistance in ohms for the RLC resistive element\n\n        Returns:\n            None\n        TODO:\n            -add assertions\n        \"\"\"\n        #add assertions\n        self.subcirc_ref=subcirc_ref\n        self.L_value=L_value\n        self.C_value=C_value\n        self.R_value=R_value\n        \n\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - RLC_s_bandpass - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RLC parallel bandpass filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        if self.subcirc_ref!=None:\n            Lref={'ref':f'L_{self.subcirc_ref}'}\n            Cref={'ref':f'C_{self.subcirc_ref}'}\n            Rref={'ref':f'R_{self.subcirc_ref}'}\n        else:\n            Lref={}\n            Cref={}\n            Rref={}\n        \n        self.l=L(value=self.L_value, **Lref)\n        self.c=C(value=self.C_value, **Cref)\n        self.r=R(value=self.R_value, **Rref)\n        \n        self.r[1, 2]+=term_0, term_2\n        self.c['p', 'n']+=term_2, term_1\n        self.l[1, 2]+=term_2, term_3\n        self.l[2]+=self.c['n']\n        \n        \n        \n        if return_elements:\n            return self.c, self.r, self.l\n    \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class filter, extract the transfer function, \n        exstract the 2Port Repersntation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes filter schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - get the Vin statement into the schematic\n        \n        \"\"\"\n        \n        self.schematic=kiwi.Circuit()\n        self.schematic.add('W 0 0_1; right')\n        self.schematic.add('W 1 1_1; right=2')\n        #self.schematic.add('P1 0 1; down, v=V_i')\n        \n        self.schematic.add(f'R 0_1 2_2; right')\n        self.schematic.add(f'C 2_2 1_1; down')\n        self.schematic.add('W 2_2 2_1; right')\n        self.schematic.add('W 1_1 3_1; right')\n        self.schematic.add(f'L 2_1 3_1; down')\n        \n        self.schematic.add('W 2_1 2; right=1.5')\n        self.schematic.add('W 3_1 3; right=1.5')\n        self.schematic.add('P2 2 3; down, v=V_o')\n        \n        if with_values:\n            self.schematic=self.schematic.subs({'R':self.R_value, 'L':self.L_value, 'C':self.C_value})\n        \n        if draw_me:\n            self.schematic.draw()\n    \n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n\n\n# In[105]:\n\n\n#instatate the rlc_bandpass filter\nbandpassRLC_p=rlc_parallel_bandpass(L_value=.0006750@u_H, C_value=3.33e-8@u_F, R_value=50@u_Ohm)\nbandpassRLC_p.lcapy_self()\n\n\n# In[106]:\n\n\n#get this filters abstract transfer function\nbandpassRLC_p.get_tf(with_values=False)\n\n\n# In[107]:\n\n\n#get this filters transfer function\nbandpassRLC_p.get_tf(with_values=True)\n\n\n# In[108]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out'); \n\n#create a 1V AC test source and attache to nets\nvs=SINEV(ac_magnitude=1@u_V); vs['p', 'n']+=net_in, gnd\n\n#attaceh term_0 to net_in and term_2 to net_out per scikit-rf convention all \n#other terminals are grounded\nbandpassRLC_p.SKiDl(net_in, gnd, net_out, gnd)\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In[109]:\n\n\nfilter_responce=qfilter_explorer(circ, 'RLC Parallel Bandpass Filter Responce');\n\n\n# In[110]:\n\n\nfilter_responce.symbolic_tf(bandpassRLC_p)\n\n\n# ### RLC parallel bandstop\n\n# In[111]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 rlc_parallel_bandstop filter class\n#class with lcapy and skidl subcircuit to create an RLC parallel bandstop filter\n\nclass rlc_parallel_bandstop():\n    \"\"\"\n    holding class for SkiDl subcircuit and lcapy schematic of a\n    bandstop parallel RLC filter primitive\n    \"\"\"\n    \n    def __init__(self, subcirc_ref=None, L_value=1@u_H, C_value=1@u_F, R_value=1@u_Ohm):\n        \"\"\"\n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            L_value (float; 1@u_F; Henerys): the inductance in farads for the RLC inductive element\n            C_value (float; 1@u_F; Farads): the capacitance in farads for the RLC capacitive element\n            R_value (float; 1@u_Ohm; Ohms): the resistance in ohms for the RLC resistive element\n\n        Returns:\n            None\n        TODO:\n            -add assertions\n        \"\"\"\n        #add assertions\n        self.subcirc_ref=subcirc_ref\n        self.L_value=L_value\n        self.C_value=C_value\n        self.R_value=R_value\n        \n\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - RLC_s_bandstop - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RLC parallel bandstop filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        if self.subcirc_ref!=None:\n            Lref={'ref':f'L_{self.subcirc_ref}'}\n            Cref={'ref':f'C_{self.subcirc_ref}'}\n            Rref={'ref':f'R_{self.subcirc_ref}'}\n        else:\n            Lref={}\n            Cref={}\n            Rref={}\n        \n        self.l=L(value=self.L_value, **Lref)\n        self.c=C(value=self.C_value, **Cref)\n        self.r=R(value=self.R_value, **Rref)\n        \n        self.c['p', 'n']+=term_0, term_2\n        self.l[1, 2]+=term_0, term_2\n        self.r[1, 2]+=term_2, term_3\n        self.r[2]+=term_1\n        \n        \n        \n        if return_elements:\n            return self.c, self.r, self.l\n    \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class filter, extract the transfer function, \n        exstract the 2Port Repersntation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes filter schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - get the Vin statement into the schematic\n        \n        \"\"\"\n        \n        self.schematic=kiwi.Circuit()\n        self.schematic.add('W 0 0_1; right')\n        self.schematic.add('W 1 3_1; right=3.5')\n        #self.schematic.add('P1 0 1; down, v=V_i')\n        \n        self.schematic.add('W 0_1, 0_2; up=.3')\n        self.schematic.add(f'L 0_2 2_3; right')\n        self.schematic.add('W 2_3 2_2; down=.3')\n        \n        self.schematic.add('W 0_1, 0_3; down=.3')\n        self.schematic.add(f'C 0_3 2_4; right')\n        self.schematic.add('W 2_4 2_2; up=.3')\n\n        self.schematic.add(f'R 2_1 3_1; down')\n\n        \n        self.schematic.add('W 2_2 2_1; right')\n        self.schematic.add('W 2_1 2; right')\n        self.schematic.add('W 3_1 3; right')\n        self.schematic.add('P2 2 3; down, v=V_o')\n        \n        if with_values:\n            self.schematic=self.schematic.subs({'R':self.R_value, 'L':self.L_value, 'C':self.C_value})\n        \n        if draw_me:\n            self.schematic.draw()\n    \n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n\n\n# In[112]:\n\n\n#instatate the rc_bandpass filter to \nbandstopRLC_p=rlc_parallel_bandstop(L_value=.0006750@u_H, C_value=3.33e-8@u_F, R_value=50@u_Ohm)\nbandstopRLC_p.lcapy_self()\n\n\n# In[113]:\n\n\n#get this filters abstract transfer function\nbandstopRLC_p.get_tf(with_values=False)\n\n\n# In[114]:\n\n\n#get this filters transfer function\nbandstopRLC_p.get_tf(with_values=True)\n\n\n# In[115]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out'); \n\n#create a 1V AC test source and attache to nets\nvs=SINEV(ac_magnitude=1@u_V); vs['p', 'n']+=net_in, gnd\n\n#attaceh term_0 to net_in and term_2 to net_out per scikit-rf convention all \n#other terminals are grounded\nbandstopRLC_p.SKiDl(net_in, gnd, net_out, gnd)\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In[116]:\n\n\nfilter_responce=qfilter_explorer(circ, 'RLC Parallel Bandstop Filter Responce');\n\n\n# In[117]:\n\n\nfilter_responce.symbolic_tf(bandstopRLC_p)\n\n\n# # All Pass filters\n\n# The naming of filters as has been seen is based on the shape of the Bode Magnitude Plot and for the most part, Phase has kind of been a ride along part of the filter design. Stating that, the name for an All-Pass filter is misleading; the better name is a Phase Shaping filter. These Filters ideally do not affect the magnitude of the signal passed through them and instead affect the phase. Here we will look at the lattice All-Pass filter for the low-frequency phase from the following Wikipedia article \n# \n# https://en.wikipedia.org/wiki/Lattice_phase_equaliser\n# \n\n# In[118]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 2 lc_balanced_allpass_lowfreq_lattice_filt filter class\n#class with lcapy and skidl subcircuit to create an lc all-pass filter\n\nclass lc_balanced_allpass_lowfreq_lattice_filt():\n    \"\"\"\n    holding class for SkiDl subcircuit and lcapy schematic of a\n    bandstop parallel RLC filter primitive\n    \"\"\"\n    \n    def __init__(self, subcirc_ref=None, L1_value=1@u_H, L2_value=1@u_H,  C1_value=1@u_F, C2_value=1@u_F):\n        \"\"\"\n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            L1_value (float; 1@u_F; Henerys): the inductance in farads for the top inductive element\n            L2_value (float; 1@u_F; Henerys): the inductance in farads for the bottom inductive element\n            C1_value (float; 1@u_F; Farads): the capacitance in farads for the term 2 to term 1 capacitive element\n            C2_value (float; 1@u_F; Farads): the capacitance in farads for the term 0 to term 2 capacitive element\n\n        Returns:\n            None\n        TODO:\n            -add assertions\n        \"\"\"\n        #add assertions\n        self.subcirc_ref=subcirc_ref\n        self.L1_value=L1_value\n        self.L2_value=L2_value\n        self.C1_value=C1_value\n        self.C2_value=C2_value\n        \n\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - RLC_s_bandstop - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RLC parallel bandstop filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        if self.subcirc_ref!=None:\n            L1ref={'ref':f'L_{self.subcirc_ref}1'}\n            L2ref={'ref':f'L_{self.subcirc_ref}2'}\n\n            C1ref={'ref':f'C_{self.subcirc_ref}1'}\n            C2ref={'ref':f'C_{self.subcirc_ref}2'}\n        else:\n            L1ref={}\n            L2ref={}\n            \n            C1ref={}\n            C2ref={}\n        \n        self.l1=L(value=self.L1_value, **L1ref)\n        self.l2=L(value=self.L2_value, **L2ref)\n\n        self.c1=C(value=self.C1_value, **C1ref)\n        self.c2=C(value=self.C2_value, **C2ref)\n        \n        \n        term_0+=self.l1[1], self.c2['p']\n        term_1+=self.l2[1], self.c1['n']\n        term_2+=self.l1[2], self.c1['p']\n        term_3+=self.l2[2], self.c2['n']   \n        \n        \n        \n        \n        if return_elements:\n            return self.c, self.r, self.l\n    \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class filter, extract the transfer function, \n        exstract the 2Port Repersntation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes filter schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - must draw this better\n            - get the Vin statement into the schematic\n            \n        \n        \"\"\"\n        \n        self.schematic=kiwi.Circuit()\n        \n        self.schematic=kiwi.Circuit()\n        #self.schematic.add('W 0 0; right')\n        #self.schematic.add('W 1 3; right=3.5')\n        #self.schematic.add('P1 0 1; down, v=V_i')\n        \n        #It ant pretty but it works\n        self.schematic.add('W 0 0_3; right')\n        self.schematic.add(f'L1 0_3 2_2; right')\n        self.schematic.add('W 2_2 2; right')\n\n        self.schematic.add('W 0 0_2; rotate=-45')\n        self.schematic.add(f'C2 0_2 3; rotate=-45')\n        \n        self.schematic.add(f'C1 2 1_2; rotate=225')\n        self.schematic.add(f'W 1_2 1; rotate=225')\n        \n        self.schematic.add('W 1 1_3; right')\n        self.schematic.add(f'L2 1_3 3_2; right=2')\n        self.schematic.add('W 3_2 3; right')\n\n        \n        if with_values:\n            self.schematic=self.schematic.subs({'L1':self.L1_value, 'L2':self.L2_value, \n                                                'C1':self.C1_value, 'C2':self.C2_value})\n        \n        if draw_me:\n            self.schematic.draw()\n    \n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n\n\n# If you're wondering what a lattice filter is, the fact of the matter is that you have seen them before in terms of bridge circuits. See the following Wikipedia article on Lattice Networks \n# \n# https://www.eeeguide.com/wp-content/uploads/2019/11/Lattice-Network.jpg\n# \n\n# In[119]:\n\n\n#instatate the allpass latice filter to \nallpasslat_lf=lc_balanced_allpass_lowfreq_lattice_filt()\nallpasslat_lf.lcapy_self()\n\n\n# In[120]:\n\n\n#get this filters abstract transfer function\nallpasslat_lf.get_tf(with_values=False)\n\n\n# In[121]:\n\n\n#get this filters transfer function\nallpasslat_lf.get_tf(with_values=True)\n\n\n# In[122]:\n\n\nreset()\n#create the nets; the last one is needed to deal with singularity issues when dealing with lattice circuits and ground\nnet_in=Net('In'); net_out=Net('Out'); net_outlower=Net('Out2')\n#create a 1V AC test source and attache to nets\nvs=SINEV(ac_magnitude=1@u_V); vs['p', 'n']+=net_in, gnd\n#net_in+=dummy_1[2]\n\n#attaceh term_0 to net_in and term_2 to net_out per scikit-rf convention all \n#other terminals are grounded\n#but need to add dummy resistors to deal with singular issues and get solvable matric\ndummy_botin=R(value=0, ref='dummy')\ndummy_botin[1]+=gnd\n\ndummy_botout=R(value=0, ref='dummy')\ndummy_botout[2]+=gnd\nallpasslat_lf.SKiDl(net_in, dummy_botin[2], net_out, dummy_botout[1])\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# The `dummy_bot*` resistors that are in the simulation are needed in order for SPICE to no longer throw a singular matrix error. Where the test circuit is drawn below. This might not be needed if the output (terminal 3) of the lattice filter was allowed to float. Floating circuits will be discussed in the next section on transformers in detail. Here all inputs and outputs will be referenced to ground.\n\n# In[123]:\n\n\nlat_testcir=kiwi.Circuit()\n\nlat_testcir.add('Vs In 0; down')\nlat_testcir.add('W 0 0_1; down=0.2, sground')\n\nlat_testcir.add('W In U1.l1; right')\nlat_testcir.add('Rdummy 0 U1.l2; right, l=0Ohm')\n\nlat_testcir.add('U1 chip2121; right, l={latice}, pinlabels={l1=0,l2=1, r1=2,r2=3}')\n\nlat_testcir.add('W U1.r1 Out; right')\nlat_testcir.add('Rdummy_1 U1.r2 Out2; right, l=0Ohm')\nlat_testcir.add('W Out2 Out2_1; down=0.2, sground')\n\n\n\nlat_testcir.draw()\n\n\n# In[124]:\n\n\nfilter_responce=qfilter_explorer(circ, 'LC All-Pass Low Frequcy Lattice Filter');\n\n\n# In[125]:\n\n\nfilter_responce.symbolic_tf(allpasslat_lf)\n\n\n# The reason it's diverging and more specifically flipped in phase might be due to how lcapy is treating the `0` as ground when it formulates the modified nodal analysis. As seen below with the lack of a `V_3` term. Going to pass on fixing this right now but it is top of the TODO list for this section\n\n# In[126]:\n\n\nallpasslat_lf.lcapy_self(False, False)\n#also wont convert to laplace\nn=kiwi.NodalAnalysis(allpasslat_lf.schematic)\nn.nodal_equations()\n\n\n# ## Citations:\n# \n# [1] ALL ABOUT ELECTRONICS. \"RC Low Pass Filter Explained,\" YouTube, Aug 20, 2017. [Video file]. Available: https://youtu.be/_2L0l-E1Wx0. [Accessed: Nov 30, 2020].\n# \n# [2] ALL ABOUT ELECTRONICS. \"RC High Pass Filter Explained,\" YouTube, Aug 23, 2017. [Video file]. Available: https://youtu.be/9Dx0b0ukNAM. [Accessed: Nov 30, 2020].\n# \n# [3] ALL ABOUT ELECTRONICS. \"Band Pass Filter and Band Stop Filter Explained,\" YouTube, Sep 2, 2017. [Video file]. Available: https://youtu.be/dmPIydL0lyM. [Accessed: Nov 30, 2020].\n# \n# [4] S. Makarov, R. Ludwig and S. Bitar, Practical electrical engineering. Cham: Springer International Publishing, 2016, pp. 514-515.\n# \n# [5] \"Lattice phase equaliser\", En.wikipedia.org, 2021. [Online]. Available: https://en.wikipedia.org/wiki/Lattice_phase_equaliser. [Accessed: 10- Jan- 2021]. \n# \n# [6] \"Lattice network\", En.wikipedia.org, 2021. [Online]. Available: https://en.wikipedia.org/wiki/Lattice_network. [Accessed: 10- Jan- 2021]. \n# \n# \n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "22f5c013af101afadcce74c233960283f134f022", "size": 143581, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/AC_2/AC_2_RCL_filters.py", "max_stars_repo_name": "PyLCARS/Python-and-SPICE-Book", "max_stars_repo_head_hexsha": "0bf02aa16d97115cea955d33a7aab7e02f8d3453", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-01-04T23:56:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-22T13:22:30.000Z", "max_issues_repo_path": "_build/jupyter_execute/AC_2/AC_2_RCL_filters.py", "max_issues_repo_name": "PyLCARS/Python-and-SPICE-Book", "max_issues_repo_head_hexsha": "0bf02aa16d97115cea955d33a7aab7e02f8d3453", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/AC_2/AC_2_RCL_filters.py", "max_forks_repo_name": "PyLCARS/Python-and-SPICE-Book", "max_forks_repo_head_hexsha": "0bf02aa16d97115cea955d33a7aab7e02f8d3453", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.1371849738, "max_line_length": 974, "alphanum_fraction": 0.6081375669, "include": true, "reason": "import numpy,import sympy", "num_tokens": 37186, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.476579651063676, "lm_q2_score": 0.18713268216242657, "lm_q1q2_score": 0.08918362836757904}}
{"text": "# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements.  See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership.  The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License.  You may obtain a copy of the License at\n#\n#   http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied.  See the License for the\n# specific language governing permissions and limitations\n# under the License.\n\"\"\"\nAuto-scheduling matrix multiplication for CPU\n=============================================\n**Author**: `Lianmin Zheng <https://github.com/merrymercy>`_, \\\n            `Chengfan Jia <https://github.com/jcf94/>`_\n\nDifferent from the existing :ref:`autotvm <tutorials-autotvm-sec>` which relies on \nmanual templates to define the search space, the auto-scheduler does not require any templates.\nThe auto-scheduler is template-free, so users only need to write the computation declaration without\nany schedule commands or templates.\nThe auto-scheduler can automatically generate a large\nsearch space and find a good schedule in the space.\n\nWe use matrix multiplication as an example in this tutorial.\n\"\"\"\n\nimport numpy as np\nimport tvm\nfrom tvm import te, testing, auto_scheduler\n\n######################################################################\n# Define the computation\n# ^^^^^^^^^^^^^^^^^^^^^^\n# To begin with, let us define the computation of a matmul with bias add.\n# The function should return the list of input/output tensors.\n# From these tensors, the auto-scheduler can get the whole computational graph.\n\n\n@auto_scheduler.register_workload\ndef matmul_add(N, L, M, dtype):\n    A = te.placeholder((N, L), name=\"A\", dtype=dtype)\n    B = te.placeholder((L, M), name=\"B\", dtype=dtype)\n    C = te.placeholder((N, M), name=\"C\", dtype=dtype)\n\n    k = te.reduce_axis((0, L), name=\"k\")\n    matmul = te.compute((N, M), lambda i, j: te.sum(A[i, k] * B[k, j], axis=k), name=\"matmul\")\n    out = te.compute((N, M), lambda i, j: matmul[i, j] + C[i, j], name=\"out\")\n\n    return [A, B, C, out]\n\n\n######################################################################\n# Create the search task\n# ^^^^^^^^^^^^^^^^^^^^^^\n# We then create a search task with N=L=M=128 and dtype=\"float32\"\n# If your machine supports avx instructions, you can\n# - replace \"llvm\" below with \"llvm -mcpu=core-avx2\" to enable AVX2\n# - replace \"llvm\" below with \"llvm -mcpu=skylake-avx512\" to enable AVX-512\n\ntarget = tvm.target.Target(\"llvm\")\ntask = auto_scheduler.create_task(matmul_add, (128, 128, 128, \"float32\"), target)\n\n# Inspect the computational graph\nprint(task.compute_dag)\n\n######################################################################\n# Next, we set parameters for the auto-scheduler.\n#\n# * `num_measure_trials` is the number of measurement trials we can use during the search.\n#   We only make 10 trials in this tutorial for a fast demonstration. In practice, 1000 is a\n#   good value for the search to converge. You can do more trials according to your time budget.\n# * In addition, we use `RecordToFile` to dump measurement records into a file `matmul.json`.\n#   The measurement records can be used to query the history best, resume the search,\n#   and do more analyses later.\n# * see :any:`auto_scheduler.auto_schedule.TuningOptions`: for more parameters\n\ntune_option = auto_scheduler.TuningOptions(\n    num_measure_trials=10, measure_callbacks=[auto_scheduler.RecordToFile(\"matmul.json\")]\n)\n\n######################################################################\n# Run the search\n# ^^^^^^^^^^^^^^\n# Now we get all inputs ready. Pretty simple, isn't it?\n# We can kick off the search and let the auto-scheduler do its magic.\n# After some measurement trials, it will return the best schedule it found.\n\nsch, args = auto_scheduler.auto_schedule(task, tuning_options=tune_option)\n\n######################################################################\n# We can lower the schedule to see the IR after auto-scheduling.\n# The auto-scheduler correctly performs optimizations including multi-level tiling,\n# parallelization, vectorization, unrolling and operator fusion.\n\nprint(tvm.lower(sch, args, simple_mode=True))\n\n######################################################################\n# Check correctness and evaluate performance\n# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n# We build the binary and check its correctness and performance.\n\nfunc = tvm.build(sch, args)\na_np = np.random.uniform(size=(128, 128)).astype(np.float32)\nb_np = np.random.uniform(size=(128, 128)).astype(np.float32)\nc_np = np.random.uniform(size=(128, 128)).astype(np.float32)\nout_np = a_np.dot(b_np) + c_np\n\nctx = tvm.cpu()\na_tvm = tvm.nd.array(a_np, ctx=ctx)\nb_tvm = tvm.nd.array(b_np, ctx=ctx)\nc_tvm = tvm.nd.array(c_np, ctx=ctx)\nout_tvm = tvm.nd.empty(out_np.shape, ctx=ctx)\nfunc(a_tvm, b_tvm, c_tvm, out_tvm)\n\n# Check results\ntvm.testing.assert_allclose(out_np, out_tvm.asnumpy(), rtol=1e-3)\n\n# Evaluate execution time.\nevaluator = func.time_evaluator(func.entry_name, ctx, min_repeat_ms=500)\nprint(\n    \"Execution time of this operator: %.3f ms\"\n    % (np.median(evaluator(a_tvm, b_tvm, c_tvm, out_tvm).results) * 1000)\n)\n\n\n######################################################################\n# Using the record file\n# ^^^^^^^^^^^^^^^^^^^^^\n# During the search, all measuremnt records are dumpped into the record\n# file \"matmul.json\". The measurement records can be used to re-apply search results,\n# resume the search, and perform other analyses.\n\n######################################################################\n# Here is an example where we load the best schedule from a file,\n# print the equivalent python schedule API, and build the binary again.\n\n# Load the measuremnt record for the best schedule\ninp, res = auto_scheduler.load_best(\"matmul.json\", task.workload_key)\n\n# Print equivalent python schedule API. This can be used for debugging and\n# learning the behavior of the auto-scheduler.\nprint(\"Equivalent python schedule:\")\nprint(task.compute_dag.print_python_code_from_state(inp.state))\n\n# Rebuild the binary. This shows how you can apply the best schedule from a\n# log file without reruning the search again.\nsch, args = task.compute_dag.apply_steps_from_state(inp.state)\nfunc = tvm.build(sch, args)\n\n######################################################################\n# A more complicated example is to resume the search.\n# In this case, we need to create the search policy and cost model by ourselves\n# and resume the status of search policy and cost model with the log file.\n# In the example below we resume the status and do more 5 trials.\n\n\ndef resume_search(task, log_file):\n    cost_model = auto_scheduler.XGBModel()\n    cost_model.update_from_file(log_file)\n    search_policy = auto_scheduler.SketchPolicy(\n        task, cost_model, init_search_callbacks=[auto_scheduler.PreloadMeasuredStates(log_file)]\n    )\n    tune_option = auto_scheduler.TuningOptions(\n        num_measure_trials=5, measure_callbacks=[auto_scheduler.RecordToFile(log_file)]\n    )\n    sch, args = auto_scheduler.auto_schedule(task, search_policy, tuning_options=tune_option)\n\n\n# resume_search(task, \"matmul.json\")\n\n######################################################################\n# .. note::\n#   We cannot run the line above because of the conflict between\n#   python's multiprocessing and tvm's thread pool.\n#   After running a tvm generated binary the python's multiprocessing library\n#   will hang forever. You have to make sure that you don't run any tvm\n#   generated binaries before calling auot-scheduler's search.\n#   To run the function above, you should comment out all code in\n#   \"Check correctness and evaluate performance\" section.\n#\n#   You should be careful about this problem in your applications.\n#   There are other workarounds for this problem.\n#   For example, you can start a new thread/process (with the builtin python library\n#   threading or multiprocessing) and run the tvm binaries in the new thread/process.\n#   This provides an isolation and avoids the conflict in the main thread/process.\n#   You can also use :any:`auto_scheduler.measure.LocalRPCMeasureContext` for auto-scheduler,\n#   as shown in the GPU tutorial (:ref:`auto-scheduler-conv-gpu`).\n", "meta": {"hexsha": "918030d21e54c95897a493609612cd0f9e0d0352", "size": 8546, "ext": "py", "lang": "Python", "max_stars_repo_path": "tutorials/auto_scheduler/tune_matmul_x86.py", "max_stars_repo_name": "ThunderDboss/incubator-tvm", "max_stars_repo_head_hexsha": "8de10e328e8480b55c140ee818a4e6c7df814bdd", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "tutorials/auto_scheduler/tune_matmul_x86.py", "max_issues_repo_name": "ThunderDboss/incubator-tvm", "max_issues_repo_head_hexsha": "8de10e328e8480b55c140ee818a4e6c7df814bdd", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tutorials/auto_scheduler/tune_matmul_x86.py", "max_forks_repo_name": "ThunderDboss/incubator-tvm", "max_forks_repo_head_hexsha": "8de10e328e8480b55c140ee818a4e6c7df814bdd", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-04-08T07:08:04.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-08T07:08:04.000Z", "avg_line_length": 44.0515463918, "max_line_length": 100, "alphanum_fraction": 0.6748186286, "include": true, "reason": "import numpy", "num_tokens": 1954, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48828339529583464, "lm_q2_score": 0.1801066618860355, "lm_q1q2_score": 0.08794309238111231}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# In[1]:\n\n\nimport numpy as np\nimport scipy.special as sci\nimport matplotlib.pyplot as plt\nfrom scipy import stats # linregress\nimport pandas as pd\nfrom IPython.display import Latex\n\n\n# # Lecture 11:  Background of Groundwater Modeling\n# \n# \n# _(The contents presented in this section were re-developed principally by Dr. P. K. Yadav. The original contents are from Prof. Rudolf Liedl)_\n# \n# ---\n# \n# ## Motivation ### \n# \n# This lecture introduces the realm of mathematical modeling realm in groundwater studies. In the previous lectures the fundamental quantities, their properties and approach to quantify them were discussed. Those information were then used to develop system equations for varieties of groundwater problems. It was discussed then that these system equations require mathematical approaches the theory for which have to be systematically discussed and understood. Groundwater modeling can then be described as the systematic use of mathematical approaches leading to solution of the groundwater problem.\n# \n# \n# Groundwater modeling is often the first step towards understanding and solving groundwater problems/issues. Groundwater modeling is a very broad topic, this and the following lectures only introduces fundamental part of groundwater modeling. In this course we focus on groundwater flow problems.\n\n# ## Introduction ##\n# \n# ### What is a Model? ###\n# \n# Very succinctly a  **model** is a representation, which may be an image or a description of a real system. The description can be of different form (e.g., scales), of different level of detail (e.g., conceptual versus mathematical). The **system** to be modeled can be a **real** or also **conceptual**. A very relevant example of a real system for this course is the Darcy's experiment (see figure below), in which water is made  to flow through the porous media.\n# \n# \n# ```{figure} images/M11_f1.png\n# ---\n# scale: 60%\n# align: center\n# name: Darcy\n# ---\n# Darcy's experimental setup<sup>[^Darcy(1856)]</sup>\n# ```\n# With Darcy's experiment, one could set-up a mathematical model to relate flow rate and hydraulic gradient ($h$). As model is _only an image_ of the real system, several assumptions have to be made in it's development. At many instances the model can not be set without these assumptions. In other cases solution of the model may not be possible without these assumptions being part of the model development. Darcy‘s Law, for instance, does not provide an exact representation of flow through individual pore channels. Rather, **average** flow behaviour through **many** pore channels is represented.\n#   \n# \n# [^Darcy(1856)]: Darcy, H., Les Fontaines Publiques de la Ville de Dijon, Dalmont, Paris, 1856.\n# \n\n# ### Model Types: Process-Based and Empirical Models ###  \n# \n# Model can be classified in many ways. The following two types of classification are a more general way to classify models:\n# \n# > 1. **Conceptual models**\n# \n# > 2. **Process-Based and Empirical Models**\n# \n# > 3. **Mathematical models**\n# \n# #### Conceptual models ####\n# \n# The **conceptual models** is classification of models that distinguishes the qualitative from the quantitative description of a real system. A **conceptual model** provides a qualitative representation of the relevant system components, processes, and impacts in the area of investigation. This representation is usually shown graphically, e.g., as block models (see figure {ref}`Cmodel`). It will be shown later that conceptual model in fact is the first block in the development of a mathematical model. \n# \n# ```{figure} images/M11_f3.png\n# ---\n# scale: 20%\n# align: center\n# name: Cmodel\n# ---\n# A conceptual model showing different components of a hydrological system that can impact groundwater.\n# ```\n# \n# \n# #### Physically based models and Empirical models ####\n# \n# The **physically based models** also referred to as **process-based** models are models that exclusively relies on the fundamental physical laws - e.g., law of conservation of mass, energy, volume. _Compartment_  based models are example of physically based models.\n# \n# Contrary to use of fundamental physical laws, **empirical models** are developed on the basis on experimental/collected data. Sorption isotherms that were developed in lecture [(10)](/contents/transport/lecture_10/22_reactive_transport) are types of emperical models. As was with the isotherms, these types of models are often based on regression analysis. Figure below show a prediction (blue) line as a predictor of data.\n# \n\n# In[2]:\n\n\nfrom myst_nb import glue\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.linear_model import LinearRegression\n\n# x from 0 to 30\nx = 30 * np.random.random((20, 1))\n\n# y = a*x + b with noise\ny = 0.2 * x + 3.0 + np.random.normal(size=x.shape)\n\n# create a linear regression model\nmodel = LinearRegression()\nmodel.fit(x, y)\n\n# predict y from the data\nx_new = np.linspace(0, 30, 100)\ny_new = model.predict(x_new[:, np.newaxis])\n\n# plot the results\nfig, ax = plt.subplots(figsize=(6, 4))\nax.scatter(x, y, c=\"red\", label = \"data\")\nax.plot(x_new, y_new, label = \"prediction\")\n\nax.set_ylabel(r'Discharge (m$^3$/s)')\nax.set_xlabel('Hydraulic Head (m)')\n\nax.axis('tight')\nax.legend()\n\nplt.close(fig)\nglue(\"em_fit\", fig, display=False ) \n\n\n# ```{glue:figure} em_fit\n# :figwidth: 600px\n# :name: \"empirical\"\n# \n# Empirical relation between hydraulic head and discharge.\n# ```\n# \n# In certain cases **hybrid models**, e.g. **semi-empirical** models can also occur. These models combines the components of empirical/numerical and analytical models. Darcy's law in fact is a semi-empirical model. On the one hand, it is based on the momentum conservation.  On the other hand, it is not possible to _strictly_ deduce the direct proportionality between flow rate and hydraulic gradient by averaging the flow behaviour over all pores.\n# \n\n# #### Mathematical models ####\n# \n# A **mathematical model** provides a quantitative representation of the relevant system components (described by for e.g., conceptual model),processes (e.g., described by physical model) and impacts in the area of investigation. The quantitative representation is based on mathematical equations. The system equations, that were developed and discussed in Lecture [(7)](/contents/flow/lecture_07/17_quantify_flow) are mathematical models. \n# \n# System equation or mathematical models can in certain cases be solved directly resulting to an _exact solution_ called **analytical solution**. Theis equation that was developed in Lecture [(8)](/contents/flow/lecture_08/18_wells) to quantify aquifer drawdown resulting from pumping of groundwater is an example of an analytical solution. \n# \n# For more complex problems, often a more natural groundwater conditions, only _approximate_ (or non-exact) solution called **numerical solution** can be  obtained. Numerical solutions are obtained after converting the system equation to so called **numerical models**. \n# \n# Our focus in this introductory modeling lecture is to understand the development and solution of _numerical model_ of simple groundwater flow problems. \n# \n# \n\n# ### Example of an Analytical Solution ###\n# \n# Consider a conceptual model presented in the Figure {ref}`Ditch`. The unconfined aquifer separates two surface exposed water bodies. The water body in the left has a higher hydraulic head ($h_0$, [L]) compared to that on the right ($h_u$). Thus the flow of water is from left water body to the right one along the separating aquifer. In this scenario one of the problem to address will be to understand how the aquifer reacts to change in heads of water bodies. Additionally, how additional water, e.g., from precipitation/recharge ($N$, [L/T]), will effect the aquifer water.\n# \n# ```{figure} images/M11_f4.png\n# ---\n# scale: 20%\n# align: center\n# name: Ditch\n# ---\n# Conceptual model of a flow between two water bodies separated by unconfined aquifer\n# ```\n# The conceptual problem can be addressed when assumptions such as steady condition prevails, Darcy's law in aquifer is valid, recharge rate are relatively low. Based on the these assumptions, one of the **mathematical model** of this conceptual problem is:\n# \n# $$\n# \\frac{\\textrm{d}}{\\textrm{d}x}\\bigg(-h \\cdot K\\cdot \\frac{\\textrm{d}h}{\\textrm{d}x}  \\bigg) = N\n# $$\n# \n# and the 2 boundary conditions:\n# \n# $$\n# h(0) = h_0 \\:\\: \\text{and} \\:\\: h(L) = h_L\n# $$\n# \n# Note that a complete formulation of mathematical model requires accompanying boundary conditions. The boundary conditions are used to uniquely define the problem. An _analytical solution_ for this mathematical model and accompanying boundary condition is:\n# \n# $$\n# h(x) = \\sqrt{h_o^2 - (h_o^2 - h_L^2)\\cdot \\frac{x}{L} + \\frac{N}{K}\\cdot x \\cdot (L-x) }\n# $$\n# \n# The solution can be used to quantify change in aquifer head $h$ with different system quantities, e.g., conductivity $K$ [L/T], recharge $N$ [L/T] water body heights $h_0,\\, h_L$ [L] along the flow direction. \n# \n# The additional tool: _Conservative Transport_ ([TOOLS](/contents/tools/1D_ditchflow)) interactively simulates the ditch flow concept in more details.\n\n# ### Example problem  ###\n# \n# ```{admonition} Ditch flow\n# Explore the effect of recharge ($N= 0$ and $N= 0.1$ mm/d) on the aquifer level for the conceptual problem provided above. Other required data are provided below. \n# The effect are to be explored at mid of the aquifer\n# ``` \n# \n# \n\n# In[3]:\n\n\nprint(\"Provided are:\\n\")\n\nK = 2E-4 # hydraulic conductivity [m/s]\nHo = 10 # head at the origin [m]\nHu = 7.5 # head at L [m]\nL = 175 #flow length [m]\nN1 = 0 # no recharge [m/s]\nN2 = 1000 # recharge [mm/a]\n\n# intermediate calculation \nx = L/2 # mid of the aquifer [m]\nN_ = N2/1000/365/86400 # recharge, [m/s]\n\n#solution\nh1=(Ho**2-(Ho**2-Hu**2)/L*x+(N1/K*x*(L-x)))**0.5\nh2=(Ho**2-(Ho**2-Hu**2)/L*x+(N_/K*x*(L-x)))**0.5\n\nprint(\"hydraulic conductivity = {} m\\nhead at origin = {} m\\nhead at L = {} m\\nflow length = {} m\\nRecharge = {} mm/a\".format(K, Ho, Hu, L, N2 ),\"\\n\")\nprint(\"The resulting head without head is {:0.2f} m \\n\".format(h1))\nprint(\"The resulting head with head is {:0.2f} m \\n\".format(h2))\n\n\n# ### Example for a Model without Analytical Solution ###\n# \n# Analytical solutions are rather an exception. Natural aquifer or groundwater system are more complex (see figure below) and therefore analytical solution are not possible. The complexity in natural system are due to parameter heterogeneity and irregular model domain boundaries, and these must be included in underlying model equation. \n# \n# \n# ```{figure} images/M11_f5.png\n# ---\n# scale: 60%\n# align: center\n# name: nummodel\n# ---\n# The numerical model of a natural aquifer\n# ```\n# \n# \n# \n\n# ## Conceptual Model to Numerical Approach ##\n# \n# The first step in modeling is to establish the purpose of the model. With that established, the development of conceptual model begins the set-up of the numerical model. This is a step-wise process that includes:\n# \n# > 1. **Conceptual model** - providing hydrogeological units within the model domain\n# \n# > 2. **Water budgeting** - identifying water containing units and characterizing it\n# \n# > 3. **Numerical model** - Combining the units of conceptual model, water budgeting components and imposing _boundary conditions._ \n# \n# ```{figure} images/M11_f6.png\n# ---\n# scale: 60%\n# align: center\n# name: nummodel\n# ---\n# The numerical model of a natural aquifer\n# ```\n# \n# The water budgeting part should include the sources of water inflowing to the system including the expected flow directions and exiting water. Estimate of Groundwater recharge, overland flow etc, are few examples of inflows. Likewise, estimate of baseflow to streams, evapotranspiration, abstraction wells etc. are outflows. Field data are required to prepare water budget.\n# \n# The type of numerical model, depending on the modeling goal and required/available data, is then decided. The model type is mostly time-related (transient, steady) and dimension-related (1D,2D, 3D). \n\n# ### Data Requirements ###\n# \n# Numerical model are often very data intensive. Several types of data of different origin are required in the development of a numerical model. These data come from site data records/maps, field works, lab works and the ancillary mathematical analysis of the field and lab data. Overall, the required data can be:\n# \n# + topographical maps (with surface waters and water divides)\n# + geological maps, geological profiles (see figure {ref}`nummodel` example)\n# + maps with isolines of aquifer bottoms / thicknesses , aquitard bottoms / thicknesses\n# + maps indicating vertical extensions of sediments under rivers and lakes\n# + hydrogeological maps (hydraulic head isolines)\n# + water level time series in observation wells and rivers\n# + time series of spring discharges\n# + maps and profiles of hydraulic conductivity or transmissivity (also for river / lake sediments mentioned above)\n# + maps and profiles of storage coefficients\n# + information on spatial and temporal variability of inflow / outflow due to \n#   - groundwater recharge                                                     \n#   - evapotranspiration                                                       \n#   - interaction between groundwater and surface water                        \n#   - groundwater abstraction                                                  \n#   - natural groundwater flow\n# \n\n# ## Example of a Groundwater Model ##\n# \n# Let us now develop an example flow model. To begin with we set-up an overly simplified model that still will require a numerical solution. \n# \n# **Step 1** - Spatial Extension\n# + Horizontal extension along $x-$direction: 4000 m\n# + Horizontal extension along $y-$direction: 2500 m\n# + vertical extension along $z$-direction: from $z = 250$ m a.s.l. at the aquifer bottom to $z= 265$ m at the aquifer top.\n# + aquifer thickness is uniform = 15 m.\n# \n# Putting these information graphically, we get the following schematic:\n# \n# ```{figure} images/M11_f7.png\n# ---\n# scale: 40%\n# align: center\n# name: nummodel_ex\n# ---\n# Spatial extension of an example numerical model\n# ```\n# The example model is 2D and we _assume_ that vertical flow components can be neglected despite the recharge vertically entering the groundwater. These kinds of simplification are quite common in the development of the numerical model. These simplifications have to be justified when presenting model results. \n# \n# **Step 2** - Hydraulic Properties \n# \n# For our example model we consider the following:\n# \n# + effective porosity ($\\eta_e$) in the model domain: 0.2 or 20%\n# + two zones with different hydraulic conductivities ($K$)\n# + two zones with different groundwater recharge\n# + A section of a river (_river reach_) is in hydraulic contact with the aquifer. i.e. there may be water transfer from the river to the aquifer (_influent conditions_) or vice versa (_effluent conditions_).\n# + inflow boundary with prescribed hydraulic heads\n# + outflow boundary with prescribed hydraulic heads\n# + two impermeable boundaries\n# \n# **Step 3** - The model purpose and conceptual model\n# \n# From our example model we intend to:\n# \n# + Abstraction of groundwater through wells is planned in the area with an overall pumping rate of 7000 m$^3$/d.\n# \n# + Water extraction is to be distributed between two wells located at $(x,y) =$ (3050 m, 1550 m) and $(x,y)$ = (3050 m, 1450 m), resp.\n# \n# + The model purpose is to outline the 50-days isochrone for both wells. \n# \n# With these information available, our conceptual model takes the following form:\n# \n# ```{figure} images/M11_f8.png\n# ---\n# scale: 25%\n# align: center\n# name: Concept_model\n# ---\n# The conceptual model of the example model\n# ```\n# **Step 4** - The numerical approach \n# \n# This is discussed in the next lecture.\n\n# \n", "meta": {"hexsha": "3de72442cda25924813af0b9ee00d60898292a2a", "size": 15852, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/contents/modeling/lecture_11/31_intro_modeling.py", "max_stars_repo_name": "prabhasyadav/iGW-I", "max_stars_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_build/jupyter_execute/contents/modeling/lecture_11/31_intro_modeling.py", "max_issues_repo_name": "prabhasyadav/iGW-I", "max_issues_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/contents/modeling/lecture_11/31_intro_modeling.py", "max_forks_repo_name": "prabhasyadav/iGW-I", "max_forks_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 48.3292682927, "max_line_length": 601, "alphanum_fraction": 0.7293716881, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 3911, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43014736319616964, "lm_q2_score": 0.20181322226037884, "lm_q1q2_score": 0.08680942541342448}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# In[1]:\n\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd \nimport ipysheet as ips\nimport panel as pn\nfrom scipy import stats \npn.extension(\"katex\") \n\n\n# # Tutorial 4 #\n# \n# + **solutions for homework problems 1 – 4**\n# \n# + **tutorial problems on effective conductivity and flow nets**\n# \n# + **homework problems on effective conductivity and flow nets**\n# \n# \n# \n# \n# \n# \n# \n# ### Solutions for Homework Problems 1 – 2 ###\n# \n# \n# \n\n# In[2]:\n\n\n#\nr1_1 = pn.pane.Markdown(\"\"\"\n\n### Homework Problem 1 ###\n\nThe pressure head in an aquifer extending over 200 km<sup>2</sup> is decreased by 1.60 m.\nDetermine the loss of groundwater in the aquifer for two scenarios:\nA. The aquifer is unconfined (storage coefficient 0.13).\nB. The aquifer is confined (storage coefficient 0.0005).\n\n\"\"\",width = 800, style={'font-size': '13pt'})  \n\nr1_2= pn.pane.PNG(\"images/T03_H1.png\", width=350)\n#r1_2 = pn.pane.PNG(\"images/T03_H1.PNG\") \n\n### Tutorial Problem 7 – Solution ###\n\n#<img src=\"images/T03_H1.PNG\" alt=\"Grosser Garten Map\"  width=\"40%\" height=\"100%\" >\n\nr1_3 = pn.pane.Markdown(\"\"\" \n### Solution - Homework Problem 1 ###\n<br> \nRelevant information can be found in Lecture L03, Slides- 28-30\n\n\"\"\",width = 800, style={'font-size': '13pt'})  \n\nr1_3b = pn.pane.LaTeX(r\"\"\" \n<br> \nThe relevant equations is:<br>\n$$\nS = \\Delta V_w/(A\\cdot \\Delta H)\n$$\n\n\"\"\",width = 800, style={'font-size': '13pt'}) \npn.Column(r1_1, r1_2, r1_3, r1_3b)   \n\n\n# In[3]:\n\n\n# Given \nA = 200 # km^2, aquifer area\nD_h = 1.6 # m, head decrease\nS_u = 0.13 # (-), Storativity unconfined aquifer\nS_c = 0.0005 # (-) Storage coefficient, confined aquifer\n\n# Solution\nDV_wu = A*S_u*D_h * 10**6 # m^3 change in water volume unconfined aquifer\nDV_wc = A*S_c*D_h* 10**6  # m^3 change in water volume unconfined aquifer\n\n# output\n\nprint(\"Change in water volume in unconfined aquifer is: {0:1.1e}\".format(DV_wu),\"m\\u00b3 \\n\")\nprint(\"Change in water volume in confined aquifer is: {0:1.1e}\".format(DV_wc),\"m\\u00b3\")\n\n\n# ## Homework Problem 2\n# \n# Conduct a sieve analysis for a dried soil sample (see data in the table below)\n# \n# 1. Draw the granulometric curve (cumulative mass distribution) and briefly characterise the sediment with regard to its major constituent(s).\n# 2. What is the coefficient of uniformity? \n# \n\n# In[4]:\n\n\n#\ntitle = [\"mesh   size  [mm] \", \"residue in the sieve [g] \", \"∑Retained %\", \"Commulative Passed %\"]\nSize = [6.3, 2, 0.63, 0.2, 0.063, \"< 0.063 /cup\"]\npassed = [11, 62, 288, 189, 42, 10]\ns2 = ips.sheet(rows=6, columns=4, row_headers=False, column_headers=title)\nips.column(0, Size, row_start=0) \nips.column(1, passed, row_start=0); s2 \n\n\n# In[5]:\n\n\n# Solution of problem 2\n\nt_sample = np.sum(passed) # g, add the residue column to get total mass\nretained_per = passed/t_sample *100 # %, # retain percentage residue/total mass\nretain_per_cumsum =np.cumsum(retained_per) # get the cummulative sum of the reatined\npassing_cumper = 100 - retain_per_cumsum # substract 100-cummsum to get passing % - the last column\n\n#Output\ns3 = ips.sheet(rows=6, columns=4, row_headers=False, column_headers=title)\nips.column(0, Size, row_start=0) \nips.column(1, passed, row_start=0); \nips.column(2, retained_per, row_start=0); \nips.column(3, passing_cumper, row_start=0); s3 \n\n\n# In[6]:\n\n\n# Plotting granulometric curve\n\nplt.rcParams['axes.linewidth']=2\nplt.rcParams['grid.linestyle']='--'\nplt.rcParams['grid.linewidth']=1\nx = np.append([20], Size[:5]) # adding for all left over.\ny = np.append([100],passing_cumper[:5])\nfig = plt.figure(figsize=(9,6));\nplt.plot(x, y, 'x-', color='red', lw=2.5); \ntics=x.tolist()\nplt.xscale('log');lw=2.5\nplt.grid(which='major', color='k', alpha=0.7) \nplt.grid(which='minor', color='k', alpha=0.3)\nplt.xticks(x, tics);  \nplt.yticks(np.arange(0,110,10));\n#plt.title('grain size distribution (combined wet sieving and sedimentation analysis)');\nplt.xlabel('grain size d [mm]');\nplt.ylabel('Cummulative Passed fraction %');\n\nplt.annotate('', xy=(0.20, 10),  xycoords='data', xytext=(0.045, 10), arrowprops=dict(arrowstyle='->', color=\"b\", lw=2.5),ha='right', va='top',)\nplt.annotate('', xy=(1.1, 60),  xycoords='data', xytext=(0.045, 60), arrowprops=dict(arrowstyle='->', color=\"b\", lw=2.5),ha='right', va='top',)\nplt.annotate(r'$d_{60}$', xy=(1, 60),  xycoords=\"data\", xytext=(0.85, -3),color='red',size=12, arrowprops=dict(arrowstyle='<-', color=\"b\", lw=2.5),ha='left', va='bottom',)\nplt.annotate(r'$d_{10}$', xy=(0.20, 10),  xycoords='data', xytext=(0.235, 1.5),color='red',size=12, arrowprops=dict(arrowstyle='<-', color=\"b\", lw=2.5),ha='right', va='top',)\nplt.rcParams[\"font.weight\"] = \"bold\"   \n\nplt.savefig(\"fig6.png\")\n\nmpl_pane = pn.pane.Matplotlib(fig, dpi=144)\n\n\n# In[7]:\n\n\n# From the figure\nd_10 = 0.22 # mm,approx, diameter 10% passing, see the arrow bottom in x-axis\nd_60 = 1.0 # mm, approx diameter 10% passing, see the arrow bottom in x-axis\n\nc_u = d_60/d_10 # [], coefficient of uniformity\n\n#Output\nprint(\"The coefficient of uniformity is: {0:1.1f}\".format(c_u)) \nr2_1 = pn.pane.Markdown(\"\"\"\n**Major constituents: coarse sand/medium sand** \"\"\", width=600, style={'font-size': '13pt', 'color': 'blue'} )\npn.Row(r2_1) \n\n\n# In[8]:\n\n\n# Tutorial Problem 11- Effective Conductivity and flow nets\nr5_1 = pn.pane.Markdown(\"\"\"\n#Tutorial Problems on Effective Conductivity and Flow Nets\n\"\"\", width = 900) \n\nr5_2 = pn.pane.Markdown(\"\"\"\n###Tutorial Problem 11: Effective Hydraulic Conductivity\nA sandy layer with a thickness of 2.5 m is embedded between two gravel layers. B\noth gravel layers have a thickness of 1.5 m and a hydraulic conductivity of 3.7·10<sup>-3</sup> m/s. \nSteady-state groundwater flow is in parallel to the layering. \nA hydraulic gradient of 0.001 and an overall discharge of 1 m³/d per unit width have been determined.\n<br><br>\na. Determine the effective hydraulic conductivity.<br><br>\nb. What is the hydraulic conductivity of the sand layer?<br><br>\nc. Which effective hydraulic conductivity would be obtained if flow was assumed perpendicular to the layering?<br><br>\nd. Calculate effective hydraulic conductivity if the angle between the flow direction and the layering equals 45°.\n\"\"\", style={'font-size': '13pt'})\n\npn.Column(r5_1, r5_2)  \n\n\n# In[9]:\n\n\n# Solution of Problem 11\nr5_3 = pn.pane.PNG(\"images/T03_TP11_a.png\", width=400)\nr5_4 = pn.pane.LaTeX(r\"\"\"\nKnown relationships are (see Lecture 05, Slides 8-13, 22):\n$$\nQ = WmK\\frac{\\Delta H}{L}\n$$\n$$\nK = \\frac{Q/W}{m\\cdot \\Delta H \\cdot L}\n$$\nWeighted arithmetic mean to determine hydraulic conductivity for sand:\n\n$$\nK = \\frac{1}{m}\\sum_{i=1}^n m_i\\cdot K_i\n$$\nwhere $i$ is different layers\n\"\"\", width = 500, style={'font-size': '13pt'})\nspacer2 = pn.Spacer(width=100)\n\npn.Row(r5_3, spacer2, r5_4)  \n\n\n# In[10]:\n\n\n#Given Solution of 11 a, b\n\nQ = 2 # m^3/d, discharge\nW = 1 # m, per unit width\nK_g = 3.7*1E-3# m/s, conductivity of gravel layer \nm_g = 1.5 # m, thickness of gravel layer\nm_s = 2.5 # m, thickness of sand layer\nm = 2*m_g + m_s # m. total thickness of aquifer\nDh_L = 0.001 # (-), hydraulic gradient\n\n\n#Solution of 11a\nKeff_h = (Q/W)/(m*Dh_L) # m/d, conductivity\nKeff_hs = Keff_h/(24*3600)# m/s, conductivity unit changed\n\n#Solution of 11b\n# K_eff = (2*m_g*K_g + m_s*K_g)/m\n\nK_s = ((m*Keff_hs - 2*m_g*K_g))/m_s  \n\nprint(\"Effective horizontal hydraulic conductivity (Keff_h) = {0:1.2f}\".format(Keff_h), \"m/d\\n\" ) \nprint(\"Effective horizontal hydraulic conductivity (Keff_hs) = {0:1.3E}\".format(Keff_hs), \"m/s\\n\" )\nprint(\"Hydraulic conductivity of sand layer (K_s) = {0:1.1E}\".format(K_s), \"m/s\" )     \n\n\n# In[11]:\n\n\n#Given Solution of 11 c, d\n\nr5_5 = pn.pane.PNG(\"images/T03_TP11_b.png\", width=200) \nr5_6 = pn.pane.PNG(\"images/T03_TP11_c.png\", width=200) \n\nr5_7 = pn.Column(r5_5, r5_6) \n\nr5_8 = pn.pane.LaTeX(r\"\"\"\nVertical effective conductivity is given by weighted harmoninc mean\n$$\nK = \\frac{m}{2\\cdot \\frac{m_g}{K_g} + \\frac{m_s}{K_s} }\n$$\n<br>\nFor inclined aquider the effective conductivity is:\n\n$$\nK = \\frac{1}{\\frac{\\cos^2\\theta}{K_h} + \\frac{\\sin^2\\theta}{K_v}}\n$$\n\n\"\"\", style={'font-size': '13pt'})\n\npn.Row(r5_7,spacer2, r5_8) \n\n\n# In[12]:\n\n\n# Solution of 11c\n\nKeff_v = m/(2*(m_g/K_g)+ (m_s/K_s))\n\n#Given \ntheta = 45 # theta \ntheta_r = 45*(np.pi)/180 # degree to radian conversion\nK_h = Keff_hs # m/s, solution from 11a\nK_v = Keff_v # m/s, solution from 11c\n\n# solution from 11d\nKeff_i = 1/((np.cos(theta_r)**2/K_h)+(np.sin(theta_r)**2/K_v))\n\n\nprint(\"Effective vertical hydraulic conductivity (Keff_v) = {0:1.2E}\".format(Keff_v), \"m/s\\n\" ) \nprint(\"Effective inclined hydraulic conductivity (Keff_i) = {0:1.2E}\".format(Keff_i), \"m/s\" ) \n\n\n# In[13]:\n\n\n#\nr6_1 = pn.pane.Markdown(\"\"\"\n### Tutorial Problem 12: Hydrologic Triangle\nThe figure below shows the position of four groundwater observation wells with measured hydraulic heads in m a.s.l. \n<br> <br>\n**a.** Sketch head isolines for intervals of 1 m by applying the hydrologic triangle method.<br><br>\n**b.** Indicate the flow direction.\n\n\"\"\",width = 400, style={'font-size': '13pt'})\n\nr6_2 = pn.pane.PNG(\"images/T03_TP12_a.png\", width=400) \n\npn.Row(r6_1,spacer2, r6_2) \n\n\n# In[14]:\n\n\n# \nr6_3 = pn.pane.Markdown(\"\"\"\n### Solution of Tutotrial Problem 12\n\nStep 1. Connects all the points\n\"\"\", width=600)\n\nr6_2.object = \"images/T03_TP12_b.png\"\nr6_3\n\n\n# In[15]:\n\n\n#\nr6_4 = pn.pane.Markdown(\"\"\"\n### Solution of Tutotrial Problem 12\nStep 2. Divide the connected lines at equal head-level (here = 1 m)\n\"\"\", width=600)\nr6_2.object = \"images/T03_TP12_c.png\"\n\n\n# In[16]:\n\n\n#\nr6_4 = pn.pane.Markdown(\"\"\"\n### Solution of Tutotrial Problem 12\nStep 3. Join all the equal head lines \n\"\"\", width=600)\nr6_2.object = \"images/T03_TP12_d.png\"\n\n\n# In[17]:\n\n\nr6_4 = pn.pane.Markdown(\"\"\"\n### Solution of Tutotrial Problem 12\nStep 4. Mark the flow direction from higher head towards lower head\n\"\"\", width=600)\nr6_2.object = \"images/T03_TP12_e.png\"\n\n\n# In[18]:\n\n\n#\nr7_1 = pn.pane.Markdown(\"\"\"\n##Tutorial Problem 13: Flow Nets##\n\nSketch head isolines and streamlines for the two configurations a) and b) of a well doublette shown below. In both cases flow nets should be sketched without and with the uniform flow component.\n\n\"\"\",width=800,  style={'font-size': '13pt'})\n\nr7_2 = pn.pane.Markdown(\"\"\"\n a) withdrawal at both wells:<br><br><br>\n\"\"\",width=400,  style={'font-size': '13pt'})\n\nr7_3 = pn.pane.PNG(\"images/T03_TP13_a.png\", width=200)  \n\nr7_4 = pn.Column(r7_2,r7_3)\n\nr7_5 = pn.pane.Markdown(\"\"\"\n b) Injection and withdrawl wells:<br><br><br>\n\"\"\",width=400,  style={'font-size': '13pt'})\n\nr7_6 = pn.pane.PNG(\"images/T03_TP13_b.png\", width=200)  \n\nr7_7 = pn.Column(r7_5,r7_6)\nr7_8 = pn.Row(r7_4, r7_7) \npn.Column(r7_1, r7_8) \n\n\n# In[19]:\n\n\nr8_1= pn.pane.Markdown(\"\"\"\n#Homework Problems on  Effective Conductivity and Flow Nets <br><br><br> \n\"\"\", width = 800, style={'font-size': '13pt'})\n\n\nr8_2= pn.pane.Markdown(\"\"\"\n#There is no obligation to solve homework problems!\n\"\"\", width = 800, style={'font-size': '13pt', 'color':'red'})\n\npn.Column(r8_1,r8_2)  \n\n\n# In[20]:\n\n\n#\nr9_1= pn.pane.Markdown(\"\"\"\n###Homework Problem 5: Effective Hydraulic Conductivity\nA gravel layer with a thickness of 2.5 m is embedded between two sand layers. Both sand layers have a thickness of \n1.5 m and a hydraulic conductivity of 3.7·10<sup>-4</sup> m/s. Steady-state groundwater flow is perpendicular to the layering. \nAn overall head difference of 5.5 cm and a discharge of 500 l/d per unit area have been determined <br><br>\n\n**a.** Determine the effective hydraulic conductivity.<br><br>\n**b.** What is the hydraulic conductivity of the gravel layer?<br><br>\n**c.** Which effective hydraulic conductivity would be obtained if flow was assumed to be in parallel with the layering?<br><br>\n**d.** Calculate effective hydraulic conductivity if the angle between the flow direction and the layering equals 30°. <br>\n\n\"\"\", width = 900, style={'font-size': '13pt'})\nr9_1\n\n\n# In[21]:\n\n\n#\nr10_1= pn.pane.Markdown(\"\"\"\n###Homework Problem 6: Hydrologic Triangle\nThe figure below shows the position of five groundwater observation wells with measured hydraulic heads in m a.s.l. \n <br><br>\n\n**a.** Sketch head isolines for intervals of 1 m by applying the hydrologic triangle method.\n<br><br>\n**b.** Indicate the flow direction.<br><br>\n\"\"\", width = 500, style={'font-size': '13pt'})\nr10_2 = pn.pane.PNG(\"images/T03_TH6.png\", width=400)  \n\npn.Row(r10_1, r10_2)\n\n\n# In[22]:\n\n\n#\nr11_1= pn.pane.Markdown(\"\"\"\n###Homework Problem 7: Flow Nets\nSketch head isolines and streamlines for the well doublette shown below. \nIn this case, injection and withdrawal of groundwater is superimposed to a uniform flow component.\n <br><br><br><br><br><br>\n \"\"\", width = 900, style={'font-size': '13pt'})\n\nr11_2 = pn.pane.PNG(\"images/T03_TH7.png\", width=400)  \n\nr11_3= pn.pane.Markdown(\"\"\"\n <br><br><br><br><br><br>\n \"\"\", width = 900, style={'font-size': '13pt'})\npn.Column(r11_1, r11_2, r11_3)\n\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "ea2d82dc51744293901c04c7e3a034e6caa9d692", "size": 12850, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/contents/tutorials/Tutorial_04.py", "max_stars_repo_name": "prabhasyadav/iGW-I", "max_stars_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_build/jupyter_execute/contents/tutorials/Tutorial_04.py", "max_issues_repo_name": "prabhasyadav/iGW-I", "max_issues_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/contents/tutorials/Tutorial_04.py", "max_forks_repo_name": "prabhasyadav/iGW-I", "max_forks_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.9957983193, "max_line_length": 194, "alphanum_fraction": 0.6823346304, "include": true, "reason": "import numpy,from scipy", "num_tokens": 4220, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48047867804790706, "lm_q2_score": 0.1801066618860355, "lm_q1q2_score": 0.0865374108106237}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Lab 1 Solutions\n# \n# ### Objectives\n# In this lab, we'll \n# - Review the computational infrastructure around our data science environments,\n# - Go through the process of ensuring that we have a Python environment set up for this class with the proper installed packages\n# - Within our environment, we'll review the basic data science operations in Python, and introduce some tips and tricks. \n# \n# \n# ```{admonition} Take a Deep Breath\n# Don't freak out if stuff presented here is brand new to you! Ask a friend, google around (esp. stack overflow) and find a solution. All of these examples can be done in a few lines of code.\n# ```\n# \n# # Part I: Computational Ecosystem \n# \n# In the space below, or in your own assignment, answer the following: \n# \n# ## Question A\n# \n# Describe the following terms, and point out the differences between them. Feel free to look things up.\n# - python:\n# - the terminal:\n# - the file system:\n# - jupyter:\n# - an IDE: \n# - a text editor:\n# - git: \n# - PATH: \n# \n\n# I am writing this lab in a notebook. We'll be discussing the pros and cons of notebooks in class. Below, I'm going to check which python installation on my computer is being pointed to within my PATH. As a reminder, you can see your full path by echoing it from the terminal. Within a notebook, that looks like this:\n\n# In[2]:\n\n\nget_ipython().system('echo $PATH')\n\n\n# ```{note}\n# The \"!\" in my notebook allows me to run terminal commands from a notebook; you don't need this symbol when running commands in an actual terminal.\n# ```\n\n# I can check my python as follows:\n\n# In[3]:\n\n\nget_ipython().system('which python')\n\n\n# We can see that calls to `python` are triggering the python installed in `anaconda3`, which is what we want (see the installation video for more details). If your call to `which python` in the terminal returns something like `usr/bin/python`, then something has likely gone wrong with your installation. There are some troubleshooting steps suggested in the installation video. \n# \n# ## Setting up an Environment. \n# \n# We can think of packages as programs installed on our computer. But what if one of my projects needs Photoshop 14.0, and another needs a feature that was only available in Photoshop 12.5.2? An environment is the system on which your code is being executed. When you fire up a terminal, this is usually your *base* environment, the default one for your *user* on a given computer system. But rather than always installing programs in this base installation, we can create custom environments for each of our projects. We can then install the exact dependencies for those projects within our environments, and we'll know they won't mess with each other. \n# \n# For this class, we're going to be doing a lot of package installations. To ensure we are all on the same page and are working with the same tools, we're going to use a `conda environment` to maintain versioning. Note: there are multiple environment creation tools/methods. Conda environments are the predominant standard in astronomy, hence their use here. \n# \n# In your terminal, type the following:\n# ```{note}\n# If you are on WINDOWS, you NEED to use the ANACONDA TERMINAL. NOT YOUR WINDOWS POWER SHELL/COMMAND PROMPT. Search your pc for anaconda and you'll see an anaconda launcher (if you followed the installation video correctly). From there, you should be able to find an anaconda terminal/prompt. That's where you should do anything whenever I say \"from your terminal\".\n# ```\n# \n# \n\n# In[ ]:\n\n\nconda create -n a330 python=3.8 \n\n\n# Once you run this, answer \"y\" to the prompts, and your new environment will be installed.\n# \n# ```{note}\n# The above command may take several minutes to execute.\n# ```\n# \n# \n# Next, we want to activate this environment (still in our terminal). We do this as follows:\n\n# In[ ]:\n\n\nconda activate a330\n\n\n# When you do so, you should see the left hand edge of your prompt switch from (base) to (a330). \n# \n# Next, let's make an alias so that getting into our a330 environment is a snap. We're going to access a file called `.bash_profile`, which allows us to set aliases and environment variables. This file is located in your home directory, so I can print mine here:\n\n# In[6]:\n\n\nget_ipython().system('more ~/.bash_profile')\n\n\n# Notice above I use the `~` which is a shorthand for home directory. On my computer, the default home directory for my user is `/Users/ipasha/`. \n# \n# \n# \n# This file has some conda stuff in it at the top, as well as some path and python path exports, as well as an alias. \n# \n# Yours should also have the conda init stuff, if you installed anaconda properly. Using your text editor of choice, add a line to this file that reads `alias a330='conda activate a330'`. \n# \n# ```{sidebar} Using Vi/vim\n# Vi/vim is a built-in terminal program that allows for the editing of files. It is helpful to learn, especially when working on remote servers. We'll go into it more later, but here is a step by step for performing the above step with vim. \n# - First: from the terminal, type `vim ~/.bash_profile` and hit enter. This will open the editor. If 'vim' isn't recognized, try 'vi'. \n# - Next: Press the \"I\" key to open insert mode. Move your cursor with the arrow keys to the desired line, then type in the alias command shown to left. \n# - Finally: Press `esc` to get out of insert mode, then type `:wq` and hit enter in order to \"write\" then \"quit\". \n# ```\n# \n# \n# \n# Now, from your terminal, source your profile by typing `source ~/.bash_profile`. You're good to go! Test that you can activate your environment by typing `a330` and hitting enter. \n# \n# ```{note}\n# To deactivate, just type `conda deactivate`. \n# ```\n# \n# \n\n# ## Adding Jupyter\n# \n# You'll be using notebooks during this class, and we need to make sure that we can access our new environment from within Jupyter notebook. To ensure this, we're going to do the following:\n# \n# First, make sure your environment is activated. \n# \n# Then, type:\n\n# In[ ]:\n\n\nconda install -c anaconda ipykernel\n\n\n# This ensures we can select different kernels inside jupyter. A kernel is basically \"the thing that is python\", the root thing being run on your system when you use python. By creating environments, we're creating different unique kernels, and we can now get to them within our notebooks. \n# \n# Now, run the following:\n\n# In[ ]:\n\n\npython -m ipykernel install --user --name=a330\n\n\n# Once you've done this, you should have the ability to access your new environment from within Jupyter. We can test this as follows: \n# - First, open a new terminal window, and activate your environment (if you made the alias, this means typing `a330` in your terminal. \n# - Next, type `jupyter lab` to open jupyter lab. If for some reason you don't have jupyter lab yet, you can install it now with `conda install -c conda-forge jupyterlab`. \n# - Once you have lab open, there should be a 'launcher' page, with one option being to create a new notebook using python -- you *should* see your environment listed there. \n# - If you don't hit refresh on the webpage just in case. \n# - You can also click on the option to open a python3 notebook. Inside, in the top right corner, it should say your current environment (probably Python 3). Clicking that, it should give you the option to choose a different environment, and your environment should be listed there. \n# \n# ```{note}\n# If you already had a lab open, you'll have to hit refresh to get it to show up. \n# ```\n# ## Installing Packages\n# \n# Now that we have our environment, we're going to install the set of packages we need for this class. We may need more of them as the semester goes on, but for now, do the following (in your terminal, within your environment). \n\n# In[ ]:\n\n\nconda install -n a330 numpy scipy astropy matplotlib \n\n\n# (again, hitting \"y\" when prompted). Again, this step might take a minute or so to run.\n# \n# Congrats, you now have an environment set up for this class, and can jump in and out of it at will, either in your terminal, or within a Jupyter notebook.\n# \n# ```{admonition} Hot Tip\n# It's highly recommended you do these steps anytime you start a new research project. Up front, you may not know all the dependencies that will arise, but as you go along, if you keep your work to that environment, you'll be able to carefully control which versions of which packages you're accessing at all times.\n# ```\n# \n# \n\n# # Part II: Python Review\n# \n# In this section, I'll ask you to perform some pythonic operations to get back into the swing of things if it has been a little while. \n# \n# For this assignment, please carry out your work in a Jupyter notebook, with the questions labeled and your output shown. You'll submit this notebook via Github, but we will discuss how to perform this step in class.\n\n# ## Question 1\n# Create a 2D array of dimensions 1000 x 1000, in which the values in each pixel are random-gaussian distributed about a mean of 10, with a sigma of 2, and then use matplotlib to display this image. Make sure (0,0) is in the lower lefthand corner. \n\n# In[145]:\n\n\nimport numpy as np\nimport scipy.stats as stats\nimport matplotlib.pyplot as plt\n\n\n# In[146]:\n\n\n# Solution 1\nmu = 10\nsigma = 2\nGauss = stats.norm(loc=mu,scale=sigma)\narray = Gauss.rvs((1000,1000))\nfig, ax = plt.subplots(figsize=(10,10))\nax.imshow(array,origin='lower');\n\n\n# In[147]:\n\n\n#Solution 2:\narray_np = np.random.normal(loc=10,scale=2,size=(1000,1000))\nfig, ax = plt.subplots(figsize=(10,10))\nax.imshow(array_np,origin='lower');\n\n\n# ## Question 2\n# \n# The distribution of pixels in your above image should not have many outliers beyond 3-sigma from the mean, but there will be some. Find the location of any 2 sigma outliers in the image, and highlight them by circling their location. \n# Confirm that the fraction of these out of the total number of pixels agrees with the expectation for a normal distribution.\n\n# In[149]:\n\n\n# Solution \noutliers = np.where((array>mu+3*sigma)|(array<mu-3*sigma))\nfig, ax = plt.subplots(figsize=(10,10))\nax.imshow(array,origin='lower')\nax.plot(outliers[0],outliers[1],'o',ms=5,color='None',mec='r');\n\n\n# ## Question 3\n# \n# When dealing with astronomical data, it is sometimes advisable to not include outliers in a calculation being performed on a set of data (in this example, an image). We know, of course, that the data we're plotting ARE coming from a gaussian distribution, so there's no reason to exclude, e.g., 3-sigma outliers, but for this example, let's assume we want to. \n# \n# Create a numpy masked array in which all pixels that are > 3$\\sigma$ from the image mean are masked. Then, calculate the mean and sigma of the new masked array. \n\n# In[34]:\n\n\n# Solution \nclipped_array = np.ma.masked_where((array>mu+3*sigma)|(array<mu-3*sigma),array)\nprint(f'Clipped Mean: {np.mean(clipped_array):.3f}  |  Clipped Sigma: {np.std(clipped_array):.3f}')\n\n\n# In[154]:\n\n\n# solution 2\nm= (array < mu+3.*sigma) & (array>mu-3.*sigma)\n\nmn = np.mean(array[m])\nst = np.std(array[m])\nprint('Clipped mean; {:0.3f};  Clipped Sigma: {:0.3f}'.format(mn,st))\n\n\n# As expected, clipping the outliers of this distribution does not affect the mean in any strong way, but does noticably decrease $\\sigma$. \n\n# ## Question 4:\n# \n# Using Array indexing, re-plot the same array from above, but zoom in on the inner 20% of the image, such that the full width is 20% of the total. Note: try not to hard code your indexing. You should be able to flexibly change the percentage. For this one, use a white-to-black color map.\n# \n\n# In[150]:\n\n\n# solution \ncent = int(array.shape[0] / 2)\nperc = int(0.2 * array.shape[0]*0.5)\ncropped_array = array[cent-perc:cent+perc,cent-perc:cent+perc]\nfig, ax = plt.subplots(figsize=(10,10))\nax.imshow(cropped_array,origin='lower',cmap='gray_r');\n\n\n# As expected, our image is now 200 by 200 pixels across. Note that our new image has its own indexing. A common \"gotcha\" when working with arrays like this is to index in, but then try to use indices found (e.g., via `where()`) in the larger array on the cropped in version, which can lead to errors.\n\n# ## Question 5\n# \n# Often, we have an expression to calculate of the form \n# \n# $$\n# \\sum_i \\sum_j a_i b_j\n# $$\n\n# Your natural impulse for coding this double sum might look like this:\n\n# In[ ]:\n\n\ntotal = 0\nfor i in a:\n    for j in b:\n         total+= i*j\n\n\n# which, mathematically, makes sense! But as it turns out, there's a way we can do this without any loops at all --- and when $\\vec{a}$ and $\\vec{b}$ get long, this becomes hugely important in our code.\n# \n# The trick we're going to use here is called [array broadcasting](https://numpy.org/doc/stable/user/basics.broadcasting.html), which you can read about at the link if you're not already familar. I'm going to give you $\\vec{a}$ and $\\vec{b}$ below. For this exercise, calculate the double sum indicated above without the use of a for-loop. \n# \n# ```{admonition} Hint\n# The command `np.newaxis` will be useful here, or for a slightly longer solution, try `np.repeat` and `reshape()`. \n# ```\n\n# In[35]:\n\n\na = np.array([1,5,10,20])\nb = np.array([1,2,4,16])\n\n# Solution\noutput = np.sum(a[:,np.newaxis]*b)\n\n\n# In[37]:\n\n\noutput\n\n\n# We can confirmed the above worked using our slow loop:\n\n# In[40]:\n\n\ntotal = 0\nfor i in a:\n    for j in b:\n         total+= i*j\ntotal\n\n\n# We can also perform this trick without knowing about `np.newaxis` explicitly. You may have done it this way. \n\n# In[55]:\n\n\nmatrix_a = np.repeat(a,len(b)).reshape(len(a),len(b))\nmatrix_b = np.repeat(b,len(a)).reshape((len(b)),len(a)).T\noutput = np.sum(matrix_a*matrix_b)\noutput\n\n\n# I want to take a moment here and really highlight the difference in speed between these two methods. Let's bump up the length... by a lot: \n\n# In[68]:\n\n\na = np.random.random(5000)\nb = np.random.random(5000)\n\n\n# In[69]:\n\n\nget_ipython().run_cell_magic('timeit', '', '\\ntotal = 0\\nfor i in a:\\n    for j in b:\\n         total+= i*j')\n\n\n# We can see that above, it took 5 whole seconds to run the cell. That's for only 5000 entries in each list. Many astronomical lists on which we might have to do this are 10,000 or more long! Notice this is an exponential operation. Try running the above on your computer with 10000 long lists. I'll wait... until you get bored and kill the process after many minutes.\n# \n# Now see below:\n\n# In[70]:\n\n\nget_ipython().run_cell_magic('timeit', '', 'output = np.sum(a[:,np.newaxis]*b)')\n\n\n# Wow. 52 ms to do that whole thing. Broadcasting. We love it, we use it, we love it. \n# \n# ```{admonition} Takeaway Point\n# The takeaway from this lesson should be that anytime we can do something without a loop... WE SHOULD.\n# ```\n# \n# \n\n# ## Question 6\n# \n# Often in astronomy we need to work with grids of values. For example, let's say we have a model that describes some data, and the model has 2 parameters, $a$ and $b$.\n# \n# We might choose different combinations of $a$ and $b$, and determine a metric for how well models of such combinations fit our data (e.g., $\\chi^2$). \n# \n# We may then want to plot this $\\chi^2$ value for each point on our grid -- that is, at each grid position corresponding to some $a_i$ and $b_j$. \n# \n# Below, I provide a function, `chi2`, which returns a single number given some singular inputs `a` and `b`. \n# \n# Create some arrays of `a` and `b` to test that range between 1 and 25, and have 10 entries evenly spaced between those values. Then, loop over them and find the $\\chi^2$ using my function. \n# ```{note}\n# We can't get around the double loop in this case, because we are operating under the assumption that the calculation of some single $\\chi^2$ using a unique combination of $a_i$ and $b_j$ cannot be vectorized. If it could, we wouldn't need to do this activity. But often, we can't, because the creation of a model given some inputs is nontrivial.\n# ```\n# \n# Once you've stored the $\\chi^2$ values for each combination of $a$ and $b$, create a plot with $a$ and $b$ as the axes and show using colored circles the $\\chi^2$ value at each location. Add a colorbar to see the values being plotted. \n# \n# To create this grid, use the `np.meshgrid()` function. For your plot, make sure the marker size is big enough to see the colors well. \n# \n# \n# \n# \n\n# In[151]:\n\n\ndef chi2(a,b):\n    return ((15-a)**2+(12-b)**2)**0.2 #note, this is nonsense, but should return a different value for each input a,b\n\n# Solution \na = np.linspace(1,25,10)\nb = np.linspace(1,25,10)\nchi2_values = []\nfor i in a:\n    for j in b:\n        chi2_values.append(chi2(i,j))\n\nchi2_values = np.array(chi2_values)\n\nxx,yy = np.meshgrid(a,b)\n\nfig, ax = plt.subplots(figsize=(12,10))\n\nim = ax.scatter(xx,yy,c=chi2_values,marker='o',s=100)\nplt.colorbar(im);\n\n\n# ## Question 7 \n# \n# Re-show your final plot above, making the following changes:\n# \n# - label your colorbar as $\\chi^2$ using latex notation, with a fontsize>13\n# - Make your ticks point inward and be longer\n# - Make your ticks appear on the top and right hand axes of the plot as well \n# - If you didn't already, label the x and y axes appropriately and with a font size > 13 \n# - Make sure the numbers along the axes have fontsizes > 13\n# \n\n# In[152]:\n\n\nfig, ax = plt.subplots(figsize=(12,10))\n\nim = ax.scatter(xx,yy,c=chi2_values,marker='o',s=100)\nax.tick_params(direction='in',right=True,top=True,length=7,width=1.5,labelsize=14)\nax.set_xlabel(r'parameter $a$',fontsize=15)\nax.set_ylabel(r'parameter $b$',fontsize=15)\ncbar = plt.colorbar(im)\ncbar.set_label(r'model $\\chi^2$',fontsize=14);\n\n\n# ## Question 8\n# \n# Some quick list comprehensions! For any unfamilar, **comprehensions** are pythonic statements that allow you to compress a for-loop (generally) into a single line, and usually runs faster than a full loop (but not by a ton). \n# \n# Take the for-loop below and write it as a list comprehension.\n\n# In[119]:\n\n\nvisited_cities = ['San Diego', 'Boston', 'New York City','Atlanta']\nall_cities = ['San Diego', 'Denver', 'Boston', 'Portland', 'New York City', 'San Francisco', 'Atlanta']\n\nnot_visited = []\nfor city in all_cities:\n    if city not in visited_cities:\n        not_visited.append(city)\n        \nprint(not_visited)\n\n\n# In[121]:\n\n\n# Solution \n\nnot_visited = [i for i in all_cities if i not in visited_cities]\nprint(not_visited)\n\n\n# Next, create an array of integers including 1 through 30, inclusive. Using a comprehension, create a numpy array containing the squared value of only the odd numbers in your original array. (*Hint, remember the modulo operator*)\n\n# In[122]:\n\n\n# Solution \nfull = np.arange(1,31)\nsquared_odds = np.array([i**2 for i in full if i%2!=0])\nprint(squared_odds)\n\n\n# In the next example, you have a list of first names and a list of last names. Use a list comprehension to create an array that is a list of full names (with a space between first and last names). \n\n# In[123]:\n\n\nfirst_names = ['Bob','Samantha','John','Renee']\nlast_names = ['Smith','Bee','Oliver','Carpenter']\n\n# Solution\nfull_names = [i+' '+j for i,j in zip(first_names,last_names)]\nprint(full_names)\n\n\n# ```{admonition} Challenge Problem (worth Extra Credit) \n# I've created new lists that contain strings of the names in the format Lastname,Firstname, with random leading/trailing spaces and terrible capitalizations. Use a list comprehension to make our nice, \"Firstname Lastname\" list again.\n# ```\n\n# In[129]:\n\n\nall_names = ['sMitH,BoB   ', '  bee,samanthA',' oLIVER,JOHN ','  caRPENTer,reneE  ']\n\n# solution \nfull_names = [i.strip().split(',')[1].upper()[0]\n              +i.strip().split(',')[1].lower()[1:]\n              +' '\n              +i.strip().split(',')[0].upper()[0]\n              +i.strip().split(',')[0].lower()[1:]\n              for i in all_names]\nprint(full_names)\n\n\n# ```{note}\n# Note that with this last example, we're entering a degree of single-line length and complexity that it almost doesn't make sense to use a comprehension anymore. Just because something CAN be done in one line doesn't mean is has to be, or should be.\n# \n# ```\n# \n# You may be wondering what use case this type of coding has in astronomy -- turns out, quite a lot. Take this example: you read in a data table and the columns have names like \"FLUX HA\", \"FLUX ERR\", etc. \n# \n# If you're trying to make a `pandas DataFrame` of this table, it is advantageous to rename these columns something like `flux_ha` and `flux_err`. This way, commands like `df.flux_ha` can be used. \n# \n# Being able to iterate over the string list of column names and turn caps into lower case, spaces into underscores, etc., is a useful skill that will come in handy when wrangling data. \n# \n# Below, for reference, I show how I myself would do the above example in production code:\n\n# In[133]:\n\n\ndef clean_csv_string(str_in,sep=',',formatting='LastFirst'):\n    str_stripped = str_in.strip() # remove trailing/leading spaces\n    str_split = str_stripped.split(sep) #split at delimiter\n    str_cap_correct = [i.upper()[0]+i.lower()[1:] for i in str_split]\n    if formatting=='LastFirst':\n        out_string = str_cap_correct[1] + ' ' + str_cap_correct[0]\n        return out_string\n    elif formmatting=='FirstLast':\n        out_string = str_cap_correct[0] + ' ' + str_cap_correct[1]\n        return out_string\n    else:\n        raise ValueError('formatting not set correctly')\n\n\n        \nfull_names = [clean_csv_string(i) for i in all_names]\nprint(full_names)\n\n\n# By making the string cleaning steps a function, I could take the time to explain what is going on within the function, as well as control for additional possibilities (like the names being in First,Last formatting). I could make this function more robust and complex, and my final comprehension stays readable and simple, as I loop over the names and run each through my handy functions (with some settings tweaked, potentially). \n\n# ## Question 9 \n# \n# Take the arrays `XX`, `YY`, and `ZZ` below and create one multidimensional array in which they are the columns. Print to confirm this worked.\n\n# In[131]:\n\n\nXX = np.array([1,2,3,4,5,6,7,8,9])\nYY = np.array([5,6,7,8,9,10,11,12,13])\nZZ = np.array([10,11,12,13,14,15,16,17,18])\n\n#solution\ncols = np.column_stack((XX,YY,ZZ))\ncols\n\n\n# ## Question 10 \n# \n# Units, units, units. The bane of every scientists' existence... except theorists that set every constant equal to 1. \n# \n# In the real world, we measure fluxes or magnitudes in astronomical images, infer temperatures and densities from data and simulations, and ultimately have to deal with units one way or another. \n# \n# Thankfully, our friends at `astropy` know this, and they've come to save the day. This next question serves as an introduction to the `units` module in astropy, which can be both a live saver and a pain in the ass, but at the end of the day is absolutely worth learning.\n\n# In[137]:\n\n\nimport astropy.units as u\n\n\n# The standard import for this library is `u`, so be careful not to name any variables that letter. \n# \n# To \"assign\" units to a variable, we multiply by the desired unit as follows. Note that generally the module knows several aliases/common abrreviations for a unit, if it is uniquely identifiable.\n\n# In[138]:\n\n\nstar_temp = 5000*u.K \nstar_radius = 0.89 * u.Rsun \nstar_mass = 0.6 * u.Msun\n\n\n# We can perform trivial conversions using the `.to()` method.\n\n# In[139]:\n\n\nstar_radius.to(u.km)\n\n\n# Once we attach units to something, it is now a `Quantity` object. Quantity objects are great, above, we saw they have built-in methods to facilitate conversion. They can also be annoying -- sometimes another function we've written needs just the raw value or array back out. To get this, we use the `.value` attribute of a quantity object:\n\n# In[140]:\n\n\nstar_mass.to(u.kg).value\n\n\n# This now strips away all `Quantity` stuff and gives us an array or value to use elsewhere in our code. \n# \n# Units are great because they help us combine quantities while tracking units and dimensional analysis. A common operation in astronomy is converting a flux to a luminosity given a distance, using \n# \n# $$\n# F = \\frac{L}{4\\pi D^2}\n# $$\n# where $L$ is the luminosity and $D$ is the distance to the source. \n# \n# What if I've made a flux measurement in astronomical units such as erg/s/cm$^2$, and I want to know the luminosity in solar luminosities, and my distance happens to be in Mpc? Regardless of my input units, I can easily do this:\n\n# In[141]:\n\n\nL = 4 * np.pi * (3.6*u.Mpc)**2 * (7.5e-14 * u.erg/u.s/u.cm**2)\nL.to(u.Lsun)\n\n\n# This conversion worked because the units worked out. If my units of flux weren't correct, I'd get an error:\n\n# In[142]:\n\n\nL = 4 * np.pi * (3.6*u.Mpc)**2 * (7.5e-14 * u.erg/u.s/u.cm**2/u.AA)\nL.to(u.Lsun)\n\n\n# Here, `units` realized that I was putting in units of flux density, but wanted a luminosity out, and ultimately those units don't resolve out. Thus, it can be a great way to catch errors in your inputs. \n# \n# Note: just be careful that sometimes, you throw a constant into an equation but the constant has some units. If you're going to use the unit module to do a calculation, ALL inputs that HAVE units must be assigned them correctly as above for it to work.\n\n# For your exercise, consider the following: \n#     \n# The virial temperature of a galaxy halo is given roughly by \n# \n# $$\n# T_{\\rm vir} \\simeq 5.6\\times10^4\\;\\textrm{K}\\left(\\frac{\\mu}{0.59}\\right)\\left(\\frac{M_{\\rm halo}}{10^{10}\\; M_{\\odot}}\\right)^{2/3}\\left(\\frac{1+z}{4}\\right)\n# $$\n\n# where here, we can assume $\\mu$ is 0.59. \n# \n# Write a function that takes as an input a halo mass, redshift, and optionally $\\mu$ (default 0.59), and returns the virial temperature in Kelvin. Your function should take in an astropy quantity with mass units, but should allow for the mass to be input with any appropriate units. \n\n# In[144]:\n\n\n# Solution \n\ndef Tvir(M,z,mu=0.59):\n    return ((5.6e4*u.K)*(mu/0.59)*(M/(1e10*u.Msun))**(2/3.)*((1+z)/4)).to(u.K)\n\nTvir(10**11*u.Msun,z=3)\n\n", "meta": {"hexsha": "e5c6d467d49d7d4745dfc25c3cd2112c955c7d4a", "size": 25859, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/Lab1/Lab1_solutions.py", "max_stars_repo_name": "Astro-330/Astro-330.github.io", "max_stars_repo_head_hexsha": "e7ba5d1db0f369a110419e939d9ed2d29c9d7020", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-08-28T23:26:14.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T14:35:17.000Z", "max_issues_repo_path": "_build/jupyter_execute/Lab1/Lab1_solutions.py", "max_issues_repo_name": "mgebran/Astro-330.github.io", "max_issues_repo_head_hexsha": "e7ba5d1db0f369a110419e939d9ed2d29c9d7020", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/Lab1/Lab1_solutions.py", "max_forks_repo_name": "mgebran/Astro-330.github.io", "max_forks_repo_head_hexsha": "e7ba5d1db0f369a110419e939d9ed2d29c9d7020", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-12-18T00:53:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T14:53:12.000Z", "avg_line_length": 38.7691154423, "max_line_length": 654, "alphanum_fraction": 0.7136780231, "include": true, "reason": "import numpy,import scipy,import astropy", "num_tokens": 6833, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.24508501313237174, "lm_q2_score": 0.34510528442897664, "lm_q1q2_score": 0.08458013316632662}}
{"text": "\n## python src/chapter2/chapter2.py\n## python3 src/chapter2/chapter2.py\n\nimport sys\nimport numpy as nm\nfrom numpy import arange\nimport matplotlib as mat\nimport matplotlib.pyplot as plt\n\nclass Chapter2:\n    '''\n    CLRS 第二章 2.1 2.2 算法函数和笔记\n    '''\n    def __init__(self, ok = 1, *args, **kwargs):       \n        '''\n        Summary\n        =\n        These are notes of Peefy CLRS chapter1\n\n        Parameters\n        =\n        *args : a tuple like\n        **kwargs : a dict like\n\n        Returns\n        =\n        self\n\n        Example\n        =\n        >>> chapter2 = Chapter2(ok = 1);\n        '''\n        self.ok = ok\n\n    def __hello():\n        pass\n\n    def insertSortAscending(self, array = []):\n        '''\n        Summary\n        =\n        插入排序的升序排列\n        \n        Parameter\n        =\n        array : a list like\n        Return\n        =\n        sortedArray : 排序好的数组\n        >>> array = [1, 3, 5, 2, 4, 6]\n        >>> Chapter2().insertSortAscending(array)\n        >>> [1, 2, 3, 4, 5, 6]\n        '''\n        A = array\n        n = len(A)\n        for j in range(1, n):\n            ## Insert A[j] into the sorted sequece A[1...j-1] 前n - 1 张牌\n            # 下标j指示了待插入到手中的当前牌，所以j的索引从数组的第二个元素开始\n            # 后来摸的牌\n            key = A[j]\n            # 之前手中的已经排序好的牌的最大索引\n            i = j - 1\n            # 开始寻找插入的位置并且移动牌\n            while(i >= 0 and A[i] > key):\n                # 向右移动牌\n                A[i + 1] = A[i]\n                # 遍历之前的牌\n                i = i - 1\n            # 后来摸的牌插入相应的位置\n            A[i + 1] = key\n        # 输出升序排序后的牌\n        return A\n\n    def insertSortDescending(self, array = []):\n        '''\n        Summary\n        =\n        插入排序的降序排列\n\n        Parameter\n        =\n        array : a list like\n\n        Return\n        =\n        sortedArray : 排序好的数组\n        >>> array = [1, 3, 5, 2, 4, 6]\n        >>> Chapter2().insertSortAscending(array)\n        >>> [6, 5, 4, 3, 2, 1]\n        '''\n        A = array\n        n = len(A)\n        for j in range(1, n):\n            ## Insert A[j] into the sorted sequece A[1...j-1] 前n - 1 张牌\n            # 下标j指示了待插入到手中的当前牌，所以j的索引从数组的第二个元素开始\n            # 后来摸的牌\n            key = A[j]\n            # 之前手中的已经排序好的牌的最大索引\n            i = j - 1\n            # 开始寻找插入的位置并且移动牌\n            while(i >= 0 and A[i] < key):\n                # 向右移动牌\n                A[i + 1] = A[i]\n                # 遍历之前的牌\n                i = i - 1\n            # 后来摸的牌插入相应的位置\n            A[i + 1] = key\n        # 输出降序排序后的牌\n        return A\n\n    def arrayContains(self, array = [], v = None):\n        '''\n        Summary\n        =\n        * a function\n        * *检测一个数组中是否包含一个元素*\n\n        Parameter\n        =\n        *array* : a list like\n        v : a element\n\n        Return\n        =\n        index:若找到返回找到的索引，没找到返回None\n\n        Example:\n        =\n        >>> array = [12, 23, 34, 45]\n        >>> v = 23\n        >>> m = 55\n        >>> Chapter2().arrayContains(array, v)\n        >>> 1\n        >>> Chapter2().arrayContains(array, m)\n        >>> None\n        '''\n        index = None\n        length = len(array)\n        for i in range(length):\n            if v == array[i]:\n                index = i\n        return index\n\n    def twoNBinNumAdd(self, A = [], B = []):\n        '''\n        Summary\n        =\n        两个存放数组A和B中的n位二进制整数相加\n\n        Parameter\n        ====\n        A : a list like and element of the list must be 0 or 1\n        B : a list like and element of the list must be 0 or 1\n\n        Return\n        ======\n        returnSum : sum of two numbers\n\n        Example:\n        =\n        >>> A = [1, 1, 0, 0]\n        >>> B = [1, 0, 0, 1]\n        >>> Chapter2().twoNBinNumAdd(A, B)\n        >>> [1, 0, 1, 0, 1]\n        '''\n        if len(A) != len(B):\n            raise Exception('length of A must be equal to length of B')\n        length = len(A)\n        # 注意：range 函数和 arange 函数都是 左闭右开区间\n        '''\n        >>> range(0,3) \n        >>> [0, 1, 2]\n        '''\n        returnSum = arange(length + 1)\n        bitC = 0\n        for i in range(length):\n            index = length - 1 - i\n            bitSum = A[index] + B[index] + bitC\n            if bitSum >= 2:\n                bitSum = 0\n                bitC = 1\n            else:\n                bitC = 0\n            returnSum[index + 1] = bitSum\n            if index == 0:\n                returnSum[0] = bitC\n        return returnSum\n\n    def selectSortAscending(self, array = []):\n        '''\n        Summary\n        =\n        选择排序的升序排列\n        \n        Parameter\n        =\n        array : a list like\n        Return\n        =\n        sortedArray : 排序好的数组\n        >>> array = [1, 3, 5, 2, 4, 6]\n        >>> Chapter2().selectSortAscending(array)\n        >>> [1, 2, 3, 4, 5, 6]\n        '''\n        A = array\n        length = len(A)\n        for j in range(length):\n            minIndex = j\n            # 找出A中第j个到最后一个元素中的最小值\n            # 仅需要在头n-1个元素上运行\n            for i in range(j, length):\n                if A[i] <= A[minIndex]:\n                    minIndex = i\n            # 最小元素和最前面的元素交换\n            min = A[minIndex]\n            A[minIndex] = A[j]\n            A[j] = min\n        return A\n\n    def note(self, *args, **kwargs):\n        '''\n        Summary\n        =\n        These are notes of Peefy CLRS chapter1\n\n        Parameters\n        =\n        *args : a tuple like\n        **kwargs : a dict like\n\n        Returns\n        =\n        self\n\n        Example\n        =\n        >>> Chapter2().note()\n        '''  \n        print('排序算法有很多，包括插入排序，冒泡排序，堆排序，归并排序，选择排序，计数排序，基数排序，桶排序，快速排序')\n        print('2.1 插入排序')\n        print('插入排序(INSERTION-SORT):输入n个数，输出n个数的升序或者降序排列')\n        print('插入排序是一个对少量元素进行排序的有效算法，工作做原理与打牌摸牌整理手中的牌差不多')\n        print('以下是Python的插入排序(升序)算法(模拟打牌)')\n        print('书中的伪代码数组索引从1开始，python数组索引从0开始')\n        A = [4, 4.5, 2, 5, 1.2, 3.5]\n        print(\"待排序的序列：\", A)\n        print(\"插入排序后的序列：\", self.insertSortAscending(A))\n        print('循环不变式主要用来帮助理解插入算法的正确性。证明循环不变式的三个性质')\n        print(' 1.初始化：在循环的第一轮迭代开始前，应该是正确的')\n        print(' 2.保持：如果在循环的某一次迭代开始之前它是正确的，那么在下一次迭代开始前，它也应该保持正确')\n        print(' 3.终止：当循环结束时，不变式给了我们一个有用的性质，有助于表明算法是正确的')\n        print('数学归纳法中，要证明某一性质是成立的，必须首先证明其基本情况和一个归纳步骤都是成立的')\n        print('插入排序的循环不变式证明：')\n        print(' 1.初始化：插入排序第一步首相将数组中第二个元素当做待插入的元素，被插入的元素只有数组中第一元素，显然一个元素是已经排序好的')\n        print(' 2.保持：证明每一轮循环都能时循环不变式保持成立,同时证明外层for循环和内层while循环同时满足循环不变式')\n        print(' 3.终止：当j大于n时，外层循环结束，新的数组包含了原来数组中的元素，并且是排序好的，算法正确')\n        print('布尔运算符and和or都具有短路运算能力')\n        print('练习2.1-1：对于序列[31, 41, 59, 26, 41, 58]首先选出序列中第二个元素41向前插入(升序)，接下来选出59向前插入，依次类推')\n        print('练习2.1-2：只要把书中插入排序中的伪代码的不等号方向更换即可')\n        A = [31, 41, 59, 26, 21, 58]\n        print('  排序好的降序序列为：', self.insertSortDescending(A))\n        print('练习2.1-3：结果如下:')\n        print('  32在序列A中的索引为(索引从0开始)：', self.arrayContains(A, 32))\n        print('  21在序列A中的索引为(索引从0开始)：', self.arrayContains(A, 21))  \n        print('练习2.1-4：两个n位二进制数相加的算法(适用于FPGA中。参考一位加法器的逻辑表达式或者数学表达式)：')\n        print(' 两个n位二进制数的和为：', self.twoNBinNumAdd([1, 1, 0, 1], [1, 0, 0, 0]))\n        # range函数和np.arange函数都是左闭右开区间\n        print('range(0,4)的值为：', [i for i in range(0,4)])\n        print('2.2 算法分析')\n        print('算法分析即指对一个算法所需要的资源进行预测')\n        print('内存，通信带宽或者计算机硬件等资源是关心的资源, 通常资源指我们希望测度的计算时间')\n        print('采用单处理器、随机存取机RAM计算模型')\n        print('RAM模型包含了真实计算机中常见的指令：算数指令(加法，减法，除法，取余，向下取整，向上取整指令)，数据移动指令(装入、存储、复制)和控制指令(条件和非条件转移、子程序调用和返回指令)')\n        print('RAM模型中的数据类型有整数类型和浮点实数类型')\n        print('算法分析所需要的数学工具包括组合数学、概率论、代数')      \n        print('需要对\"运行时间\"和\"输入规模\"更仔细地加以定义')\n        print('插入排序算法的分析')\n        print('插入排序INSERTION=SORT过程的时间开销与输入有关，排序1000个数的事件比排序三个数的时间要长')\n        print('插入算法即使对给定规模的输入，运行时间也有可能依赖于给定的是该规模下的哪种输入')\n        print('插入排序当输入是最好情况(即输入的序列已经按顺序排好)，插入排序所需要的时间随输入规模是线性的O(n)')\n        print('插入排序当输入是按照逆序排序的(降序排列输入后输出升序排列),就会出现最坏情况,所需要时间是输入规模的二次函数O(n^2)')\n        print('一般考察算法的最坏情况运行时间')\n        print('当然对于一些\"随机化\"算法，其行为即使对于固定的输入，运行时间也是可以变化的')\n        print('做进一步的抽象：即运行时间的增长率，只考虑算法运行时间公式中的最高次项，并且忽略最高次项的常数系数,时间复杂度')\n        print('练习题2.2-1: n^3/1000 - 100n^2 - 100n + 3 的时间复杂度：O(n^3)')\n        print('练习题2.2-2:选择排序如下：')\n        A = [21, 11, 9, 66, 51, 48]\n        print(' 选择排序排列前的元素：', A)\n        print(' 选择排序排列后的元素：', self.selectSortAscending(A))\n        print(' 选择排序最好情况o(n^2),最坏情况o(n^2)')\n        print(' 因为在第n-1次比较选择的时候已经比较出了最大元素和次大元素并选择，所以这时选择完之后第n个元素已经是最大值，没有必要再比较下去了')\n        print('练习题2.2-3:线性查找最好情况是o(1),最坏情况是o(n)，平均情况是(n)')\n        print('要使算法具有较好的最佳情况运行时间就一定要对输入进行控制，使之偏向能够使得算法具有最佳运行情况的排列。')\n\n        #python src/chapter2/chapter2.py\n        #python3 src/chapter2/chapter2.py\n        return self\n\nif __name__ == '__main__':\n    print('Run main : single chapter two!')\n    Chapter2().note()\nelse:\n    pass\n\n## python src/chapter2/chapter2.py\n## python3 src/chapter2/chapter2.py\n\n", "meta": {"hexsha": "13030ab6af2e5ca96937fc6f17193f6ee01c0fdb", "size": 8684, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/chapter2/chapter2.py", "max_stars_repo_name": "DuGuPeefy/CLRS_dugu_code-master", "max_stars_repo_head_hexsha": "cc0b44f76c1306915e11c744f7f10aa20c98ac0d", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/chapter2/chapter2.py", "max_issues_repo_name": "DuGuPeefy/CLRS_dugu_code-master", "max_issues_repo_head_hexsha": "cc0b44f76c1306915e11c744f7f10aa20c98ac0d", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/chapter2/chapter2.py", "max_forks_repo_name": "DuGuPeefy/CLRS_dugu_code-master", "max_forks_repo_head_hexsha": "cc0b44f76c1306915e11c744f7f10aa20c98ac0d", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.1035598706, "max_line_length": 109, "alphanum_fraction": 0.5038000921, "include": true, "reason": "import numpy,from numpy", "num_tokens": 3884, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.1688569605068544, "lm_q1q2_score": 0.08376889617066521}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # ETHZ: 227-0966-00L\n# # Quantitative Big Imaging\n# # March 14, 2019\n#\n# ## Basic Segmentation and Discrete Binary Structures\n# ### Part 1\n\n# # Lesson Outline\n# - Motivation\n# - Qualitative Approaches\n# - Thresholding\n#  - Other types of images\n#  - Selecting a good threshold\n# - Implementation\n# - Morphology\n# - Contouring / Mask Creation\n\n# ### Applications\n#\n# - Simple two-phase materials (bone, cells, etc)\n#   - Beyond 1 channel of depth\n# - Multiple phase materials\n# - Filling holes in materials\n# - Segmenting Fossils\n# - Attempting to segment the cortex in brain imaging\n# ![Cortex Image](ext-figures/cortex.png)\n\n# # Literature / Useful References\n#\n# - John C. Russ, “The Image Processing Handbook”,(Boca Raton, CRC Press)\n#  - Available [online](http://dx.doi.org/10.1201/9780203881095) within domain ethz.ch (or proxy.ethz.ch / public VPN)\n#\n# ### Models / ROC Curves\n#\n# - [Julia Evans - Recalling with Precision](https://www.youtube.com/watch?v=ryZL4XNUmwo)\n# - [Stripe's Next Top Model](https://github.com/stripe/topmodel)\n\n# # Motivation:  Why do we do imaging experiments?\n#\n#\n# - Exploratory\n#  - To visually, qualitatively examine samples and differences between them\n#  - No prior knowledge or expectations\n# - To test a hypothesis\n#  - Quantitative assessment coupled with statistical analysis\n#  - Does temperature affect bubble size?\n#  - Is this gene important for cell shape and thus mechanosensation in bone?\n#  - Does higher canal volume make bones weaker?\n#  - Does the granule shape affect battery life expectancy?\n#\n\n# - What we are looking at\n# ![Standard Cell, http://en.wikipedia.org/wiki/File:Average_prokaryote_cell-_en.svg](ext-figures/Average_prokaryote_cell.svg)\n# - What we get from the imaging modality\n\n# In[1]:\n\n\nfrom skimage.io import imread\nfrom skimage.color import rgb2gray\nimport matplotlib.pyplot as plt\n\ndkimg = imread(\"../common/figures/Average_prokaryote_cell.jpg\")\nplt.matshow(rgb2gray(dkimg), cmap=\"bone\")\n\n\n# # To test a hypothesis\n# - We perform an experiment bone to see how big the cells are inside the tissue\n# $$\\downarrow$$ ![Bone Measurement](ext-figures/tomoimage.png)\n#\n# ### 2560 x 2560 x 2160 x 32 bit = 56GB / sample\n# - Filtering and Preprocessing!\n# $$\\downarrow$$\n# - 20h of computer time later ...\n# - 56GB of less noisy data\n# - Way too much data, we need to reduce\n#\n\n# # What did we want in the first place\n#\n#\n# ### _Single number_:\n# * volume fraction,\n# * cell count,\n# * average cell stretch,\n# * cell volume variability\n\n# # Why do we perform segmentation?\n#\n# - In model-based analysis every step we peform, simple or complicated is related to an underlying model of the system we are dealing with\n# - [_Occam's Razor_](http://en.wikipedia.org/wiki/Occams_Razor) is very important here : The simplest solution is usually the right one\n#  - Bayesian, neural networks optimized using genetic algorithms with Fuzzy logic has a much larger parameter space to explore, establish sensitivity in, and must perform much better and be tested much more thoroughly than thresholding to be justified.\n#  - We will cover some of these techniques in the next 2 lectures since they can be very powerful particularly with unknown data\n\n# # Review: Filtering and Image Enhancement\n#\n#\n# - This was a noise process which was added to otherwise clean imaging data\n# - $$ I_{measured}(x,y) = I_{sample}(x,y) + \\text{Noise}(x,y) $$\n# - What would the perfect filter be\n#  - $$ \\textit{Filter} \\ast I_{sample}(x,y) = I_{sample}(x,y) $$\n#  - $$ \\textit{Filter} \\ast \\text{Noise}(x,y) = 0 $$\n#  - $$ \\textit{Filter} \\ast I_{measured}(x,y) = \\textit{Filter} \\ast I_{real}(x,y) + \\textit{Filter}\\ast \\text{Noise}(x,y) \\rightarrow \\bf I_{sample}(x,y) $$\n# - What most filters end up doing\n# $$ \\textit{Filter} \\ast I_{measured}(x,y) = 90\\%  I_{real}(x,y) + 10\\% \\text{Noise}(x,y) $$\n# - What bad filters do\n# $$ \\textit{Filter} \\ast I_{measured}(x,y) = 10\\% I_{real}(x,y) + 90\\% \\text{Noise}(x,y) $$\n\n# # Qualitative Metrics: What did people used to do?\n#\n# - What comes out of our detector / enhancement process\n\n# In[2]:\n\n\nfrom skimage.io import imread\nfrom skimage.color import rgb2gray\nimport matplotlib.pyplot as plt\n\ndkimg = rgb2gray(imread(\"../common/figures/Average_prokaryote_cell.jpg\"))\nfig, (ax_hist, ax_img) = plt.subplots(1, 2, figsize=(12, 6))\n\nax_hist.hist(dkimg.ravel())\nax_hist.set_xlabel(\"Absorption Coefficient\")\nax_hist.set_ylabel(\"Pixel Count\")\n\nm_show_obj = ax_img.matshow(dkimg, cmap=\"bone\")\ncb_obj = plt.colorbar(m_show_obj)\ncb_obj.set_label(\"Absorption Coefficient\")\n\n\n# - Identify objects by eye\n#  - Count, describe qualitatively: \"many little cilia on surface\", \"long curly flaggelum\", \"elongated nuclear structure\"\n# - Morphometrics\n#  - Trace the outline of the object (or sub-structures)\n#  - Can calculate the area by using equal-weight-paper\n#  - Employing the \"[cut-and-weigh](http://ion.chem.usu.edu/~sbialkow/Classes/361/GC/GC.html)\" method\n#\n\n# # Segmentation Approaches\n#\n#\n# They match up well to the world view / perspective\n#\n# ![Approaches](../common/figures/approaches.png)\n\n# ### Model-Based\n#\n# - $\\rightarrow$ Experimentalist\n# - Problem-driven\n#  - Top-down\n#  - _Reality_ Model-based\n#\n#\n# ### Machine Learning Approach\n#\n# - $\\rightarrow$ Computer Vision / Deep Learning\n# - Results-driven\n\n# # Model-based Analysis\n#\n# ![Traditional Imaging](../common/figures/image-formation.png)\n#\n# - Many different imaging modalities ( $\\mu \\textrm{CT}$ to MRI to Confocal to Light-field to AFM).\n# - Similarities in underlying equations\n#  - different coefficients, units, and mechanism\n#\n# $$ I_{measured}(\\vec{x}) = F_{system}(I_{stimulus}(\\vec{x}),S_{sample}(\\vec{x})) $$\n\n# # Direct Imaging (simple)\n#\n# In many setups there is un-even illumination caused by incorrectly adjusted equipment and fluctations in power and setups\n#\n# - $F_{system}(a,b) = a*b$\n# - $I_{stimulus} = \\textrm{Beam}_{profile}$\n# - $S_{system} = \\alpha(\\vec{x})$\n#\n# $\\longrightarrow \\alpha(\\vec{x})=\\frac{I_{measured}(\\vec{x})}{\\textrm{Beam}_{profile}(\\vec{x})}$\n#\n#\n\n# In[3]:\n\n\nfrom skimage.io import imread\nfrom skimage.color import rgb2gray\nimport matplotlib.pyplot as plt\nfrom skimage.morphology import disk\nfrom scipy.ndimage import zoom\nimport numpy as np\n\ncell_img = 1 - rgb2gray(imread(\"../common/figures/Average_prokaryote_cell.jpg\"))\ns_beam_img = np.pad(\n    disk(2) / 1.0, [[1, 1], [1, 1]], mode=\"constant\", constant_values=0.2\n)\nbeam_img = zoom(s_beam_img, [cell_img.shape[0] / 7.0, cell_img.shape[1] / 7.0])\n\nfig, (ax_beam, ax_img, ax_det) = plt.subplots(1, 3, figsize=(12, 4))\n\nax_beam.imshow(beam_img, cmap=\"hot\")\nax_beam.set_title(\"Beam Profile\")\n\nax_img.imshow(cell_img, cmap=\"hot\")\nax_img.set_title(\"Sample Profile\")\n\nax_det.imshow(cell_img * beam_img, cmap=\"hot\")\nax_det.set_title(\"Detector\")\n\n\n# In[4]:\n\n\nfig, (ax_prof) = plt.subplots(1, 1, figsize=(12, 4))\n\nax_prof.plot(beam_img[beam_img.shape[0] // 2], label=\"Beam Profile\")\nax_prof.plot(cell_img[beam_img.shape[0] // 2], label=\"Sample Image\")\nax_prof.plot((cell_img * beam_img)[beam_img.shape[0] // 2], label=\"Detector\")\nax_prof.set_ylabel(\"Intensity\")\nax_prof.set_xlabel(\"Pixel Position\")\n# make an interactive plot\nimport plotly.offline as py\nimport plotly.tools as tls\n\npy.init_notebook_mode()\npy.iplot(tls.mpl_to_plotly(fig))\n\n\n# Frequently there is a fall-off of the beam away from the center (as is the case of a Gaussian beam which frequently shows up for laser systems). This can make extracting detail away from the center challenging\n\n# In[5]:\n\n\nfig, ax1 = plt.subplots(1, 1, figsize=(8, 8))\nax1.matshow(cell_img * beam_img, cmap=\"hot\")\n\n\n# # Absorption Imaging (X-ray, Ultrasound, Optical)\n#\n# - For absorption/attenuation imaging $\\rightarrow$ [Beer-Lambert Law](http://en.wikipedia.org/wiki/Attenuation_coefficient)\n#  $$ I_{detector} = \\underbrace{I_{source}}_{I_{stimulus}}\\underbrace{\\exp(-\\alpha d)}_{S_{sample}} $$\n#  - Different components have a different $\\alpha$ based on the strength of the interaction between the light and the chemical / nuclear structure of the material\n# $$ I_{sample}(x,y) = I_{source}\\exp(-\\alpha(x,y) d) $$\n# $$ \\alpha = f(N,Z,\\sigma,\\cdots) $$\n#\n# - For segmentation this model is:\n#  - there are 2 (or more) distinct components that make up the image\n#  - these components are distinguishable by their values (or vectors, colors, tensors, ...)\n#\n\n# In[6]:\n\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\n\nI_source = 1.0\nd = 1.0\nalpha_1 = np.random.normal(1, 0.25, size=100)\nalpha_2 = np.random.normal(2, 0.25, size=100)\nalpha_3 = np.random.normal(3, 0.5, size=100)\n\nabs_df = pd.DataFrame(\n    [\n        dict(alpha=c_x, material=c_mat)\n        for c_vec, c_mat in zip(\n            [alpha_1, alpha_2, alpha_3], [\"material 1\", \"material 2\", \"material 3\"]\n        )\n        for c_x in c_vec\n    ]\n)\nabs_df[\"I_detector\"] = I_source * np.exp(-abs_df[\"alpha\"] * d)\n\nfig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12, 8))\nfor c_mat, c_df in abs_df.groupby(\"material\"):\n    ax1.scatter(x=c_df[\"alpha\"], y=c_df[\"I_detector\"], label=c_mat)\n    ax3.hist(c_df[\"alpha\"], alpha=0.5, label=c_mat)\n    ax2.hist(c_df[\"I_detector\"], alpha=0.5, label=c_mat, orientation=\"horizontal\")\nax1.set_xlabel(\"$\\\\alpha(x,y)$\", fontsize=15)\nax1.set_ylabel(\"$I_{detector}$\", fontsize=18)\nax1.legend()\nax2.legend()\nax3.legend(loc=0)\n\nax4.axis(\"off\")\n\n\n# # Example Mammography\n# Mammographic imaging is an area where model-based absorption imaging is problematic. Even if we assume a constant illumination (_rarely_ the case),\n#\n# $$ I_{detector} = \\underbrace{I_{source}}_{I_{stimulus}}\\underbrace{\\exp(-\\alpha d)}_{S_{sample}} $$\n# $$ \\downarrow $$\n# $$ I_{detector} = \\exp(-\\alpha(x,y) d(x,y)) $$\n# $$ \\downarrow $$\n# $$ I_{detector} = \\exp(-\\int_{0}^{l}\\alpha(x,y, z) dz) $$\n#\n\n# Specifically the problem is related to the inability to separate the $\\alpha$ and $d$ terms. We model a basic breast volume as a half sphere with a constant absorption factor.\n#\n# $$\\alpha(x,y,z) = 1e-2$$\n#\n# The $\\int$ then turns into a $\\Sigma$ in discrete space\n\n# In[7]:\n\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom skimage.morphology import ball\n\nbreast_mask = ball(50)[:, 50:]\n\n# just for 3d rendering, don't worry about it\nimport plotly.offline as py\nfrom plotly.figure_factory import create_trisurf\n\npy.init_notebook_mode()\nfrom skimage.measure import marching_cubes_lewiner\n\nvertices, simplices, _, _ = marching_cubes_lewiner(breast_mask > 0)\nx, y, z = zip(*vertices)\nfig = create_trisurf(\n    x=x, y=y, z=z, plot_edges=False, simplices=simplices, title=\"Breast Phantom\"\n)\npy.iplot(fig)\n\n\n# In[8]:\n\n\nbreast_alpha = 1e-2\nbreast_vol = breast_alpha * breast_mask\ni_detector = np.exp(-np.sum(breast_vol, 2))\n\nfig, (ax_hist, ax_breast) = plt.subplots(1, 2, figsize=(20, 8))\n\nb_img_obj = ax_breast.imshow(i_detector, cmap=\"bone_r\")\nplt.colorbar(b_img_obj)\n\nax_hist.hist(i_detector.flatten())\nax_hist.set_xlabel(\"$I_{detector}$\")\nax_hist.set_ylabel(\"Pixel Count\")\n\n\n# If we know that $\\alpha$ is constant we can reconstruct d from the image\n\n# In[9]:\n\n\nbreast_thickness = -np.log(i_detector) / breast_alpha\nfig, (ax_hist, ax_breast) = plt.subplots(1, 2, figsize=(12, 5))\n\nb_img_obj = ax_breast.imshow(breast_thickness, cmap=\"bone\")\nplt.colorbar(b_img_obj)\n\nax_hist.hist(breast_thickness.flatten())\nax_hist.set_xlabel(\"Breast Thickness ($d$)\\nIn Pixels\")\nax_hist.set_ylabel(\"Pixel Count\")\n\n\n# In[10]:\n\n\nfrom mpl_toolkits.mplot3d import Axes3D\n\nfig = plt.figure(figsize=(8, 4), dpi=200)\nax = fig.gca(projection=\"3d\")\n# Plot the surface.\nyy, xx = np.meshgrid(\n    np.linspace(0, 1, breast_thickness.shape[1]),\n    np.linspace(0, 1, breast_thickness.shape[0]),\n)\nsurf = ax.plot_surface(\n    xx, yy, breast_thickness, cmap=plt.cm.jet, linewidth=0, antialiased=False\n)\nax.view_init(elev=30, azim=45)\nax.set_zlabel(\"Breast Thickness\")\n\n\n# We run into problems when the $\\alpha$ is no longer constant. For example if we place a dark lump in the center of the breast. It is impossible to tell if the breast if thicker or if the lump inside is denser. For the lump below we can see on the individual slices of the sample that the lesion appears quite clearly and is very strangely shaped.\n\n# In[11]:\n\n\nbreast_vol = breast_alpha * breast_mask\nrenorm_slice = np.sum(breast_mask[10:40, 0:25], 2) / np.sum(breast_mask[30, 10])\nbreast_vol[10:40, 0:25] /= np.stack([renorm_slice] * breast_vol.shape[2], -1)\n\nfrom skimage.util import montage as montage2d\n\nfig, ax1 = plt.subplots(1, 1, figsize=(12, 12))\nax1.imshow(\n    montage2d(breast_vol.swapaxes(0, 2).swapaxes(1, 2)[::3]),\n    cmap=\"bone\",\n    vmin=breast_alpha * 0.8,\n    vmax=breast_alpha * 1.2,\n)\n\n\n# When we make the projection and apply Beer's Law we see that it appears as a relatively constant region in the image\n\n# In[12]:\n\n\ni_detector = np.exp(-np.sum(breast_vol, 2))\n\nfig, (ax_hist, ax_breast) = plt.subplots(1, 2, figsize=(20, 8))\n\nb_img_obj = ax_breast.imshow(i_detector, cmap=\"bone_r\")\nplt.colorbar(b_img_obj)\n\nax_hist.hist(i_detector.flatten())\nax_hist.set_xlabel(\"$I_{detector}$\")\nax_hist.set_ylabel(\"Pixel Count\")\n\n\n# And as a flat constant region in the thickness reconstruction. So we fundamentally from this single image cannot answer is the breast oddly shaped or does it have an possible tumor inside of it\n\n# In[13]:\n\n\nbreast_thickness = -np.log(i_detector) / 1e-2\nfig, (ax_hist, ax_breast) = plt.subplots(1, 2, figsize=(12, 5))\n\nb_img_obj = ax_breast.imshow(breast_thickness, cmap=\"bone\")\nplt.colorbar(b_img_obj)\n\nax_hist.hist(breast_thickness.flatten())\nax_hist.set_xlabel(\"Breast Thickness ($d$)\\nIn Pixels\")\nax_hist.set_ylabel(\"Pixel Count\")\n\n\n# In[14]:\n\n\nfrom mpl_toolkits.mplot3d import Axes3D\n\nfig = plt.figure(figsize=(8, 4), dpi=200)\nax = fig.gca(projection=\"3d\")\n# Plot the surface.\nyy, xx = np.meshgrid(\n    np.linspace(0, 1, breast_thickness.shape[1]),\n    np.linspace(0, 1, breast_thickness.shape[0]),\n)\nsurf = ax.plot_surface(\n    xx, yy, breast_thickness, cmap=plt.cm.jet, linewidth=0, antialiased=False\n)\nax.view_init(elev=30, azim=130)\nax.set_zlabel(\"Breast Thickness\")\n\n\n# # Where does segmentation get us?\n#\n#\n# - We convert a decimal value (or something even more complicated like 3 values for RGB images, a spectrum for hyperspectral imaging, or a vector / tensor in a mechanical stress field)\n# - to a single, discrete value (usually true or false, but for images with phases it would be each phase, e.g. bone, air, cellular tissue)\n#\n# - __2560 x 2560 x 2160 x 32 bit = 56GB / sample__\n# $$\\downarrow$$\n# - 2560 x 2560 x 2160 x **1 bit** = 1.75GB / sample\n#\n\n# # Applying a threshold to an image\n# Start out with a simple image of a cross with added noise\n# $$ I(x,y) = f(x,y) $$\n\n# In[15]:\n\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\n\nnx = 5\nny = 5\nxx, yy = np.meshgrid(\n    np.arange(-nx, nx + 1) / nx * 2 * np.pi, np.arange(-ny, ny + 1) / ny * 2 * np.pi\n)\ncross_im = 1.5 * np.abs(np.cos(xx * yy)) / (\n    np.abs(xx * yy) + (3 * np.pi / nx)\n) + np.random.uniform(-0.25, 0.25, size=xx.shape)\nplt.matshow(cross_im, cmap=\"hot\")\nplt.colorbar()\n\n\n# The intensity can be described with a probability density function\n# $$ P_f(x,y) $$\n\n# In[16]:\n\n\nfig, ax1 = plt.subplots(1, 1)\nax1.hist(cross_im.ravel(), 20)\nax1.set_title(\"$P_f(x,y)$\")\nax1.set_xlabel(\"Intensity\")\nax1.set_ylabel(\"Pixel Count\")\n\n\n# # Applying a threshold to an image\n#\n# By examining the image and probability distribution function, we can _deduce_ that the underyling model is a whitish phase that makes up the cross and the darkish background\n#\n# Applying the threshold is a deceptively simple operation\n#\n# $$ I(x,y) =\n# \\begin{cases}\n# 1, & f(x,y)\\geq0.40 \\\\\n# 0, & f(x,y)<0.40\n# \\end{cases}$$\n\n# In[17]:\n\n\nfig, ax1 = plt.subplots(1, 1)\nax1.imshow(cross_im, cmap=\"hot\", extent=[xx.min(), xx.max(), yy.min(), yy.max()])\nthresh_img = cross_im > 0.4\n\nax1.plot(\n    xx[np.where(thresh_img)],\n    yy[np.where(thresh_img)],\n    \"ks\",\n    markerfacecolor=\"green\",\n    alpha=0.5,\n    label=\"threshold\",\n    markersize=20,\n)\nax1.legend()\n\n\n# # Various Thresholds\n# We can see the effect of choosing various thresholds\n#\n\n# In[18]:\n\n\nfig, m_axs = plt.subplots(3, 3, figsize=(15, 15))\nfor c_thresh, ax1 in zip(np.linspace(0.1, 0.9, 9), m_axs.flatten()):\n\n    ax1.imshow(cross_im, cmap=\"bone\", extent=[xx.min(), xx.max(), yy.min(), yy.max()])\n    thresh_img = cross_im > c_thresh\n\n    ax1.plot(\n        xx[np.where(thresh_img)],\n        yy[np.where(thresh_img)],\n        \"rs\",\n        alpha=0.5,\n        label=\"img>%2.2f\" % c_thresh,\n        markersize=20,\n    )\n    ax1.legend(loc=1)\n\n\n# # Segmenting Cells\n#\n# - We can peform the same sort of analysis with this image of cells\n# - This time we can derive the model from the basic physics of the system\n#  - The field is illuminated by white light of nearly uniform brightness\n#  - Cells absorb light causing darker regions to appear in the image\n#  - _Lighter_ regions have no cells\n#  - __Darker__ regions have cells\n\n# In[19]:\n\n\nfrom skimage.io import imread\nfrom skimage.color import rgb2gray\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ncell_img = rgb2gray(imread(\"../common/figures/Cell_Colony.jpg\"))\nfig, (ax_hist, ax_img) = plt.subplots(1, 2, figsize=(12, 6))\nax_hist.hist(cell_img.ravel(), np.arange(255))\nax_obj = ax_img.matshow(cell_img, cmap=\"bone\")\nplt.colorbar(ax_obj)\n\n\n# In[20]:\n\n\nfrom skimage.color import label2rgb\n\nfig, m_axs = plt.subplots(3, 3, figsize=(15, 15), dpi=200)\nfor c_thresh, ax1 in zip(np.linspace(100, 200, 9), m_axs.flatten()):\n    thresh_img = cell_img < c_thresh\n\n    ax1.imshow(label2rgb(thresh_img, image=1 - cell_img, bg_label=0, alpha=0.4))\n\n    ax1.set_title(\"img<%2.2f\" % c_thresh)\n\n\n# # Other Image Types\n#\n# While scalar images are easiest, it is possible for any type of image\n# $$ I(x,y) = \\vec{f}(x,y) $$\n\n# In[21]:\n\n\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nnx = 10\nny = 10\nxx, yy = np.meshgrid(\n    np.linspace(-2 * np.pi, 2 * np.pi, nx), np.linspace(-2 * np.pi, 2 * np.pi, ny)\n)\n\nintensity_img = 1.5 * np.abs(np.cos(xx * yy)) / (\n    np.abs(xx * yy) + (3 * np.pi / nx)\n) + np.random.uniform(-0.25, 0.25, size=xx.shape)\n\nbase_df = pd.DataFrame(\n    dict(x=xx.ravel(), y=yy.ravel(), I_detector=intensity_img.ravel())\n)\n\nbase_df[\"x_vec\"] = base_df.apply(\n    lambda c_row: c_row[\"x\"]\n    / np.sqrt(1e-2 + np.square(c_row[\"x\"]) + np.square(c_row[\"y\"])),\n    1,\n)\nbase_df[\"y_vec\"] = base_df.apply(\n    lambda c_row: c_row[\"y\"]\n    / np.sqrt(1e-2 + np.square(c_row[\"x\"]) + np.square(c_row[\"y\"])),\n    1,\n)\n\nbase_df.head(5)\n\n\n# In[22]:\n\n\nimport seaborn as sns\n\nsns.pairplot(base_df)\n\n\n# In[23]:\n\n\nfig, ax1 = plt.subplots(1, 1, figsize=(8, 8))\nax1.quiver(\n    base_df[\"x\"],\n    base_df[\"y\"],\n    base_df[\"x_vec\"],\n    base_df[\"y_vec\"],\n    base_df[\"I_detector\"],\n    cmap=\"hot\",\n)\n\n\n# # Applying a threshold\n#\n# A threshold is now more difficult to apply since there are now two distinct variables to deal with. The standard approach can be applied to both\n# $$ I(x,y) =\n# \\begin{cases}\n# 1, & \\vec{f}_x(x,y) \\geq0.25 \\text{ and}\\\\\n# & \\vec{f}_y(x,y) \\geq0.25 \\\\\n# 0, & \\text{otherwise}\n# \\end{cases}$$\n\n# In[24]:\n\n\nthresh_df = base_df.copy()\nthresh_df[\"thresh\"] = thresh_df.apply(\n    lambda c_row: c_row[\"x_vec\"] > 0.25 and c_row[\"y_vec\"] > 0.25, 1\n)\n\nfig, ax1 = plt.subplots(1, 1, figsize=(8, 8))\nax1.quiver(\n    thresh_df[\"x\"],\n    thresh_df[\"y\"],\n    thresh_df[\"x_vec\"],\n    thresh_df[\"y_vec\"],\n    thresh_df[\"thresh\"],\n    cmap=\"hot\",\n)\n\n\n# This can also be shown on the joint probability distribution as\n\n# In[25]:\n\n\nfig, ax1 = plt.subplots(1, 1, figsize=(4, 4), dpi=200)\nax1.hist2d(thresh_df[\"x_vec\"], thresh_df[\"y_vec\"], cmap=\"hot\")\nax1.set_xlabel(\"$\\\\vec{f}_x(x,y)$\")\nax1.set_ylabel(\"$\\\\vec{f}_y(x,y)$\")\n\n\n# # Applying a threshold\n# Given the presence of two variables; however, more advanced approaches can also be investigated. For example we can keep only components parallel to the x axis by using the dot product.\n# $$ I(x,y) =\n# \\begin{cases}\n# 1, & |\\vec{f}(x,y)\\cdot \\vec{i}| = 1 \\\\\n# 0, & \\text{otherwise}\n# \\end{cases}$$\n\n# # Looking at Orientations\n# We can tune the angular acceptance by using the fact $$\\vec{x}\\cdot\\vec{y}=|\\vec{x}| |\\vec{y}| \\cos(\\theta_{x\\rightarrow y}) $$\n# $$ I(x,y) =\n# \\begin{cases}\n# 1, & \\cos^{-1}(\\vec{f}(x,y)\\cdot \\vec{i}) \\leq \\theta^{\\circ} \\\\\n# 0, & \\text{otherwise}\n# \\end{cases}$$\n", "meta": {"hexsha": "4860374ff94fe108570b8f6018940558ef2350f6", "size": 20374, "ext": "py", "lang": "Python", "max_stars_repo_path": "Lectures/04-BasicSegmentation.py", "max_stars_repo_name": "kmader/qbi-2019-py", "max_stars_repo_head_hexsha": "25ca789cc35e02ac02eaa5e1943093ef55c096a5", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-11-06T16:20:50.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-11T03:38:02.000Z", "max_issues_repo_path": "Lectures/04-BasicSegmentation.py", "max_issues_repo_name": "kmader/qbi-2019-py", "max_issues_repo_head_hexsha": "25ca789cc35e02ac02eaa5e1943093ef55c096a5", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-11-06T16:41:39.000Z", "max_issues_repo_issues_event_max_datetime": "2019-11-07T13:02:17.000Z", "max_forks_repo_path": "Lectures/04-BasicSegmentation.py", "max_forks_repo_name": "kmader/qbi-2019-py", "max_forks_repo_head_hexsha": "25ca789cc35e02ac02eaa5e1943093ef55c096a5", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-04-09T10:43:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-09T10:43:55.000Z", "avg_line_length": 28.6151685393, "max_line_length": 348, "alphanum_fraction": 0.6891135761, "include": true, "reason": "import numpy,from scipy", "num_tokens": 6163, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.45326184801538616, "lm_q2_score": 0.18476751289253923, "lm_q1q2_score": 0.08374806434687902}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # 16 - AgriPV - 3-up and 4-up collector optimization\n# \n# \n# This journal helps the exploration of varying collector widths and xgaps in the ground underneath as well as on the rear irradiance for bifacial AgriPV. The optimization varies the numpanels combinations with xgaps for having 3-up and 4-up collectors with varying space along the row (xgap). The actual raytracing is not performed in the jupyter journal but rather on the HPC, but the geometry is the same as presented here.\n# \n# The steps on this journal:\n# <ol>\n#     <li> <a href='#step1'> Making Collectors for each number panel and xgap case </a></li> \n#     <li> <a href='#step2'> Builds the Scene so it can be viewed with rvu </a></li> \n# \n# \n# An area of 40m x 20 m area is sampled on the HPC, and is highlighted in the visualizations below with an appended terrain of 'litesoil'. The image below shows the two extremes of the variables optimized and the raytrace results, including the worst-case shading experienced under the array ( 100 - min_irradiance *100 / GHI).\n# \n# \n# \n# ![AgriPV Collector Width and Xgap Optimization](../images_wiki/AdvancedJournals/AgriPV_CWandXgap_Optimization.PNG)\n# \n\n# In[1]:\n\n\nimport os\nfrom pathlib import Path\n\ntestfolder = Path().resolve().parent.parent / 'bifacial_radiance' / 'TEMP' /  'Tutorial_16'\nif not os.path.exists(testfolder):\n    os.makedirs(testfolder)\n\nprint (\"Your simulation will be stored in %s\" % testfolder)\n\n\n# In[2]:\n\n\nimport bifacial_radiance\nimport numpy as np\n\nrad_obj = bifacial_radiance.RadianceObj('tutorial_16', str(testfolder)) \n\n\n# <a id='step1'></a>\n\n# ## 1. Making Collectors for each number panel and xgap case\n\n# In[3]:\n\n\nx = 2\ny = 1\nygap = 0.1524 # m = 6 in\nzgap = 0.002 # m, veyr little gap to torquetube.\n\ntubeParams = {'diameter':0.15,\n              'tubetype':'square',\n              'material':'Metal_Grey',\n              'axisofrotation':True,\n               'visible': True}\n\nft2m = 0.3048\nxgaps = [3, 4, 6, 9, 12, 15, 18, 21]\nnumpanelss = [3, 4]\n\n\n# Loops\nfor ii in range(0, len(numpanelss)):\n    numpanels = numpanelss[ii]\n    for jj in range(0, len(xgaps)):\n        xgap = xgaps[jj]*ft2m\n\n        moduletype = 'test-module_'+str(numpanels)+'up_'+str(round(xgap,1))+'xgap'\n        rad_obj.makeModule(moduletype, \n                    x=x, y=y, \n                    xgap=xgap, zgap=zgap, ygap = ygap, numpanels=numpanels, \n                    tubeParams=tubeParams)\n\n\n# <a id='step2'></a>\n\n# ## 2. Build the Scene so it can be viewed with rvu\n\n# In[4]:\n\n\nxgaps = np.round(np.array([3, 4, 6, 9, 12, 15, 18, 21]) * ft2m,1)\nnumpanelss = [3, 4]\nsensorsxs = np.array(list(range(0, 201)))   \n\n# Select CASE:\nxgap = np.round(xgaps[-1],1)\nnumpanels = 4\n\n# All the rest\n\nft2m = 0.3048\nhub_height = 8.0 * ft2m\ny = 1\npitch = 0.001 # If I recall, it doesn't like when pitch is 0 even if it's a single row, but any value works here. \nygap = 0.15\ntilt = 18\n\nsim_name = ('Coffee_'+str(numpanels)+'up_'+\n            str(round(xgap,1))+'_xgap')\n\nalbedo = 0.35 # Grass value from Torres Molina, \"Measuring UHI in Puerto Rico\" 18th LACCEI \n            # International Multi-Conference for Engineering, Education, and Technology\n\nazimuth = 180\nif numpanels == 3:\n    nMods = 9\nif numpanels == 4:\n    nMods = 7\nnRows = 1\n\nmoduletype = 'test-module_'+str(numpanels)+'up_'+str(round(xgap,1))+'xgap'\n\nrad_obj.setGround(albedo)\nlat = 18.202142\nlon = -66.759187\nmetfile = rad_obj.getEPW(lat,lon)\nrad_obj.readWeatherFile(metfile)\n\nsceneDict = {'tilt':tilt,'pitch':pitch,'hub_height':hub_height,'azimuth':azimuth, 'nMods': nMods, 'nRows': nRows} \nscene = rad_obj.makeScene(module=moduletype,sceneDict=sceneDict,  radname = sim_name)\n\nrad_obj.gendaylit(4020)\n\n\noctfile = rad_obj.makeOct(filelist = rad_obj.getfilelist(), octname = rad_obj.basename)  \n\nname='SampleArea'\ntext='! genbox litesoil cuteBox 40 20 0.01 | xform -t -20 -10 0.01'\ncustomObject =rad_obj.makeCustomObject(name,text)\nrad_obj.appendtoScene(scene.radfiles, customObject, '!xform -rz 0')\n\noctfile = rad_obj.makeOct(rad_obj.getfilelist())  \n\n\n# \n# ### To View the generated Scene, you can navigate to the testfolder on a terminal and use:\n# \n# <b>front view:<b>\n# > rvu -vf views\\front.vp -e .0265652 -vp 2 -21 2.5 -vd 0 1 0 makemod.oct\n# \n# <b> top view: </b>\n# > rvu -vf views\\front.vp -e .0265652 -vp 5 0 70 -vd 0 0.0001 -1 makemod.oct\n#     \n# ### Or run it directly from Jupyter by removing the comment from the following cell:\n# \n\n# In[5]:\n\n\n\n## Comment the ! line below to run rvu from the Jupyter notebook instead of your terminal.\n## Simulation will stop until you close the rvu window\n\n#!rvu -vf views\\front.vp -e .0265652 -vp 2 -21 2.5 -vd 0 1 0 makemod.oct\n#!rvu -vf views\\front.vp -e .0265652 -vp 5 0 70 -vd 0 0.0001 -1 makemod.oct\n\n", "meta": {"hexsha": "d55ee118bd3f4348551af4c9c648fd48b54e6807", "size": 4772, "ext": "py", "lang": "Python", "max_stars_repo_path": "docs/tutorials/16 - AgriPV - 3-up and 4-up collector optimization.py", "max_stars_repo_name": "kperrynrel/bifacial_radiance", "max_stars_repo_head_hexsha": "cf5ae46b4ef93990e3e1619956a186376cb4fd8a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "docs/tutorials/16 - AgriPV - 3-up and 4-up collector optimization.py", "max_issues_repo_name": "kperrynrel/bifacial_radiance", "max_issues_repo_head_hexsha": "cf5ae46b4ef93990e3e1619956a186376cb4fd8a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/tutorials/16 - AgriPV - 3-up and 4-up collector optimization.py", "max_forks_repo_name": "kperrynrel/bifacial_radiance", "max_forks_repo_head_hexsha": "cf5ae46b4ef93990e3e1619956a186376cb4fd8a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.2760736196, "max_line_length": 426, "alphanum_fraction": 0.6766554904, "include": true, "reason": "import numpy", "num_tokens": 1550, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.17328819952513227, "lm_q1q2_score": 0.08258562966314019}}
{"text": "# -*- coding: utf-8 -*-\n# ---\n# jupyter:\n#   jupytext:\n#     cell_metadata_filter: all\n#     formats: ipynb,py:percent\n#     notebook_metadata_filter: all,-language_info,-toc,-latex_envs\n#     text_representation:\n#       extension: .py\n#       format_name: percent\n#       format_version: '1.3'\n#       jupytext_version: 1.3.0\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# %% [markdown] toc=true\n#\n# # Plotting\n#\n# single: MatPlotLib single: plots\n#\n# The graphical representation of data---plotting---is one of the most\n# important tools for evaluating and understanding scientific data and\n# theoretical predictions. However, plotting is not a part of core Python\n# but is provided through one of several possible library modules. The\n# most highly developed and widely used plotting package for Python is\n# MatPlotLib (<http://MatPlotLib.sourceforge.net/>). It is a powerful and\n# flexible program that has become the *de facto* standard for 2-d\n# plotting with Python.\n#\n# Because MatPlotLib is an external library---in fact it's a collection of\n# libraries---it must be imported into any routine that uses it.\n# MatPlotLib makes extensive use of NumPy so the two should be imported\n# together. Therefore, for any program for which you would like to produce\n# 2-d plots, you should include the lines\n#\n# ``` python\n# import numpy as np\n# import matplotlib.pyplot as plt\n# ```\n#\n# There are other MatPlotLib sub-libraries, but the `pyplot` library\n# provides nearly everything that you need for 2-d plotting. The standard\n# prefix for it is `plt`. The two statements above must appear before any\n# calls to NumPy or MatPlotLib routines are made.\n#\n# One final word before we get started: We only scratch the surface of\n# what is possible using MatPlotLib and as you become familiar with it,\n# you will surely want to do more than this manual describes. In that\n# case, you need to go the the web to get more information. A good place\n# to start is <http://matplotlib.org/api/pyplot_summary.html>. Another\n# interesting web page is <http://matplotlib.org/gallery.html>.\n#\n# An interactive session with `pyplot`\n# ------------------------------------\n#\n# single: plots; interactive\n#\n# We begin with an interactive plotting session that illustrates some very\n# basic features of MatPlotLib. Type in the `plot` command shown below and\n# press the return key. Take care to follow the exact syntax.\n#\n# ``` ipython\n# In [1]: plt.plot([1,2,3,2,3,4,3,4,5])\n# Out[1]: [<MatPlotLib.lines.Line2D at 0x94e1310>]\n# ```\n#\n# <figure>\n# <img src=\"attachment:zigzagPlotDemo.png\" class=\"align-center\" alt=\"\" /><figcaption>Interactive plot window</figcaption>\n# </figure>\n#\n# A window should appear with a plot that looks something like the\n# `fig-zigzagPlotDemo` shown here. By default, the `plot` function draws a\n# line between the data points that were entered. You can save this plot\n# to an image file by clicking on the floppy disk icon at the top of the\n# plot window. You can also zoom, pan, scroll through the plot, and return\n# to the original view using the other icons in the plot window.\n# Experimenting with them reveals their functions.\n#\n# When you are finished, be sure to close the plot window.\n#\n# Let's take a closer look at the `plot` function. It is used to plot\n# $x$-$y$ data sets and is written like this\n#\n# ``` python\n# plt.plot(x, y)\n# ```\n#\n# where `x` and `y` are arrays (or lists) that have the same size. If the\n# `x` array is missing, that is, if there is only a single array, as in\n# our example above, the `plot` function uses `0, 1, ..., N-1` for the `x`\n# array, where `N` is the size of the `y` array. Thus, the `plot` function\n# provides a quick graphical way of examining a data set.\n#\n# More typically, you supply both an $x$ and a $y$ data set to plot.\n# Taking things a bit further, you may also want to plot several data sets\n# on the same graph, use symbols as well as lines, label the axes, create\n# a title and a legend, and control the color of symbols and lines. All of\n# this is possible but requires calling a number of plotting functions.\n# For this reason, plotting is usually done using a Python script or\n# program.\n#\n# Basic plotting\n# --------------\n#\n# single: plots; basic\n#\n# The quickest way to learn how to plot using the MatPlotLib library is by\n# example. For our first task, let's plot the sine function over the\n# interval from 0 to $4\\pi$. The main plotting function `plot` in\n# MatPlotLib does not plot functions *per se*, it plots $(x,y)$ data\n# points. As we shall see, we can instruct the function `plot` either to\n# just draw point---or dots---at each data point, or we can instruct it to\n# draw straight lines between the data points. To create the illusion of\n# the smooth function that the sine function is, we need to create enough\n# $(x,y)$ data points so that when `plot` draws straight lines between the\n# data points, the function appears to be smooth. The sine function\n# undergoes two full oscillations with two maxima and two minima between 0\n# and $4\\pi$. So let's start by creating an array with 33 data points\n# between 0 and $4\\pi$, and then let MatPlotLib draw a straight line\n# between them. Our code consists of four parts\n#\n# -   import the NumPy and MatPlotLib modules (lines 1-2 below)\n# -   create the $(x,y)$ data arrays (lines 3-4 below)\n# -   have `plot` draw straight lines between the $(x,y)$ data points\n#     (line 5 below)\n# -   display the plot in a figure window using the `show` function (line\n#     6 below)\n#\n# Here is our code, which consists of only 6 lines:\n#\n# ``` python\n# import numpy as np\n# import matplotlib.pyplot as plt\n# x = np.linspace(0, 4.*np.pi, 33)\n# y = np.sin(x)\n# plt.plot(x, y)\n# plt.show()\n# ```\n#\n# <figure>\n# <img src=\"attachment:sinePlot.png\" class=\"align-center\" alt=\"\" /><figcaption>Sine function</figcaption>\n# </figure>\n#\n# Only 6 lines suffice to create the plot, which consists of the sine\n# function over the interval from 0 to $4\\pi$, as advertised, as well as\n# axes annotated with nice whole numbers over the appropriate interval.\n# It's a pretty nice plot made with very little code.\n#\n# One problem, however, is that while the plot oscillates like a sine\n# wave, it is not smooth. This is because we did not create the $(x,y)$\n# arrays with enough data points. To correct this, we need more data\n# points. The plot below was created using the same program shown above\n# but with 129 $(x,y)$ data points instead of 33. Try it out your self by\n# copying the above program and replacing 33 in line 3 with 129 so that\n# the function `linspace` creates an array with 129 data points instead of\n# 33.\n#\n# <figure>\n# <img src=\"attachment:sinePlotDenserXY.png\" class=\"align-center\" alt=\"\" /><figcaption>Sine function plotted using more data points</figcaption>\n# </figure>\n#\n# The code above illustrates how plots can be made with very little code\n# using the MatPlotLib module. In making this plot, MatPlotLib has made a\n# number of choices, such as the size of the figure, the blue color of the\n# line, even the fact that by default a line is drawn between successive\n# data points in the $(x,y)$ arrays. All of these choices can be changed\n# by explicitly instructing MatPlotLib to do so. This involves including\n# more arguments in the function calls we have used and using new\n# functions that control other properties of the plot. The next example\n# illustrates a few of the simpler embellishments that are possible.\n#\n# In the `fig-WavyPulse` figure, we plot two $(x,y)$ data sets: a smooth\n# line curve and some data represented by red circles. In this plot, we\n# label the $x$ and $y$ axes, create a legend, and draw lines to indicate\n# where $x$ and $y$ are zero. The code that creates this plot is shown\n# below.\n#\n# ``` python\n# import numpy as np\n# import matplotlib.pyplot as plt\n#\n# # read data from file\n# xdata, ydata = np.loadtxt('wavePulseData.txt', unpack=True)\n#\n# # create x and y arrays for theory\n# x = np.linspace(-10., 10., 200)\n# y = np.sin(x) * np.exp(-(x/5.0)**2)\n#\n# # create plot\n# plt.figure(1, figsize = (6,4) )\n# plt.plot(x, y, 'b-', label='theory')\n# plt.plot(xdata, ydata, 'ro', label=\"data\")\n# plt.xlabel('x')\n# plt.ylabel('transverse displacement')\n# plt.legend(loc='upper right')\n# plt.axhline(color = 'gray', zorder=-1)\n# plt.axvline(color = 'gray', zorder=-1)\n#\n# # save plot to file\n# plt.savefig('WavyPulse.pdf')\n#\n# # display plot on screen\n# plt.show()\n# ```\n#\n# <figure>\n# <img src=\"attachment:WavyPulse.png\" class=\"align-center\" alt=\"\" /><figcaption>Wavy pulse</figcaption>\n# </figure>\n#\n# If you have read the first four chapters, the code in lines 1-9 in the\n# above script should be familiar to you. Fist, the script loads the NumPy\n# and MatPlotLib modules, then reads data from a data file into two\n# arrays, `xdata` and `ydata`, and then creates two more arrays, `x` and\n# `y`. The first pair or arrays, `xdata` and `ydata`, contain the $x$-$y$\n# data that are plotted as red circles in the `fig-WavyPulse` figure; the\n# arrays created in line 8 and 9 contain the $x$-$y$ data that are plotted\n# as a blue line.\n#\n# The functions that do the plotting begin on line 12. Let's go through\n# them one by one and see what they do. You will notice in several cases\n# that *keyword arguments* (`kwargs`) are used in several cases. Keyword\n# arguments are *optional* arguments that have the form `kwarg=` *data*,\n# where *data* might be a number, a string, a tuple, or some other form of\n# data.\n#\n# > `figure()`  \n# > creates a blank figure window. If it has no arguments, it creates a\n# > window that is 8 inches wide and 6 inches high by default, although\n# > the size that appears on your computer depends on your screen's\n# > resolution. For most computers, it will be much smaller. You can\n# > create a window whose size differs from the default using the optional\n# > keyword argument `figsize`, as we have done here. If you use\n# > `figsize`, set it equal to a 2-element tuple where the elements are\n# > the width and height, respectively, of the plot. Multiple calls to\n# > `figure()` opens multiple windows: `figure(1)` opens up one window for\n# > plotting, `figure(2)` another, and `figure(3)` yet another.\n# >\n# > `plot(x, y,` *optional arguments* `)`  \n# > graphs the $x$-$y$ data in the arrays `x` and `y`. The third argument\n# > is a format string that specifies the color and the type of line or\n# > symbol that is used to plot the data. The string `'ro'` specifies a\n# > red (`r`) circle (`o`). The string `'b-'` specifies a blue (`b`) solid\n# > line (`-`). The keyword argument `label` is set equal to a string that\n# > labels the data if the `legend` function is called subsequently.\n# >\n# > `xlabel(` *string* `)`  \n# > takes a string argument that specifies the label for the graph's\n# > $x$-axis.\n# >\n# > `ylabel(` *string* `)`  \n# > takes a string argument that specifies the label for the graph's\n# > $y$-axis.\n# >\n# > `legend()`  \n# > makes a legend for the data plotted. Each $x$-$y$ data set is labeled\n# > using the string that was supplied by the `label` keyword in the\n# > `plot` function that graphed the data set. The `loc` keyword argument\n# > specifies the location of the legend.\n# >\n# > `axhline()`  \n# > draws a horizontal line across the width of the plot at `y=0`. The\n# > optional keyword argument `color` is a string that specifies the color\n# > of the line. The default color is black. The optional keyword argument\n# > `zorder` is an integer that specifies which plotting elements are in\n# > front of or behind others. By default, new plotting elements appear\n# > *on top of* previously plotted elements and have a value of\n# > `zorder=0`. By specifying `zorder=-1`, the horizontal line is plotted\n# > *behind* all existing plot elements that have not be assigned an\n# > explicit `zorder` less than -1.\n# >\n# > `axvline()`  \n# > draws a vertical line from the top to the bottom of the plot at `x=0`.\n# > See `axhline()` for explanation of the arguments.\n# >\n# > `savefig(` *string* `)`  \n# > saves the figure to data data file with a name specified by the string\n# > argument. The string argument can also contain path information if you\n# > want to save the file so some place other than the default directory.\n# >\n# > `show()`  \n# > displays the plot on the computer screen. No screen output is produced\n# > before this function is called.\n#\n# single: MatPlotLib functions; figure single: MatPlotLib functions; plot\n# single: MatPlotLib functions; xlabel, ylabel single: MatPlotLib\n# functions; legend single: MatPlotLib functions; ayhline, axhline single:\n# MatPlotLib functions; savefig single: MatPlotLib functions; show\n#\n# To plot the solid blue line, the code uses the `'b-'` format specifier\n# in the `plot` function call. It is important to understand that\n# MatPlotLib draws *straight lines* between data points. Therefore, the\n# curve will appear smooth only if the data in the NumPy arrays are\n# sufficiently dense. If the space between data points is too large, the\n# straight lines the `plot` function draws between data points will be\n# visible. For plotting a typical function, something on the order of\n# 100-200 data points usually produces a smooth curve, depending on just\n# how curvy the function is. On the other hand, only two points are\n# required to draw a smooth straight line.\n#\n# Detailed information about the MatPlotLib plotting functions are\n# available online, starting with the site\n# <http://matplotlib.org/api/pyplot_summary.html>. The main MatPlotLib\n# site is <http://matplotlib.org/>.\n#\n# ### Specifying line and symbol types and colors\n#\n# In the above example, we illustrated how to draw one line type (solid),\n# one symbol type (circle), and two colors (blue and red). There are many\n# more possibilities, which are specified in the tables below. The way it\n# works is to specify a string consisting of one or more plotting format\n# specifiers. There are two types of format specifiers, one for the line\n# or symbol type and another for the color. It does not matter in which\n# order the format specifiers are listed in the string. Examples are given\n# following the two tables. Try them out to make sure you understand how\n# these plotting format specifiers work.\n#\n# single: plots; line and symbol specifiers\n#\n# The first table below shows the characters used to specify the line or\n# symbol type that is used. If a line type is chosen, the lines are drawn\n# between the data points. If a marker type is chosen, the a marker is\n# plotted at each data point.\n#\n# > <table>\n# > <colgroup>\n# > <col style=\"width: 16%\" />\n# > <col style=\"width: 33%\" />\n# > <col style=\"width: 16%\" />\n# > <col style=\"width: 33%\" />\n# > </colgroup>\n# > <thead>\n# > <tr class=\"header\">\n# > <th>character</th>\n# > <th>description</th>\n# > <th>character</th>\n# > <th>description</th>\n# > </tr>\n# > </thead>\n# > <tbody>\n# > <tr class=\"odd\">\n# > <td><code>-</code></td>\n# > <td>solid line style</td>\n# > <td><code>3</code></td>\n# > <td>tri_left marker</td>\n# > </tr>\n# > <tr class=\"even\">\n# > <td><code>--</code></td>\n# > <td>dashed line style</td>\n# > <td><code>4</code></td>\n# > <td>tri_right marker</td>\n# > </tr>\n# > <tr class=\"odd\">\n# > <td><code>-.</code></td>\n# > <td>dash-dot line style</td>\n# > <td><code>s</code></td>\n# > <td>square marker</td>\n# > </tr>\n# > <tr class=\"even\">\n# > <td><code>:</code></td>\n# > <td>dotted line style</td>\n# > <td><code>p</code></td>\n# > <td>pentagon marker</td>\n# > </tr>\n# > <tr class=\"odd\">\n# > <td><code>.</code></td>\n# > <td>point marker</td>\n# > <td><code>*</code></td>\n# > <td>star marker</td>\n# > </tr>\n# > <tr class=\"even\">\n# > <td><code>,</code></td>\n# > <td>pixel marker</td>\n# > <td><code>h</code></td>\n# > <td>hexagon1 marker</td>\n# > </tr>\n# > <tr class=\"odd\">\n# > <td><code>o</code></td>\n# > <td>circle marker</td>\n# > <td><code>H</code></td>\n# > <td>hexagon2 marker</td>\n# > </tr>\n# > <tr class=\"even\">\n# > <td><code>v</code></td>\n# > <td>triangle_down marker</td>\n# > <td><code>+</code></td>\n# > <td>plus marker</td>\n# > </tr>\n# > <tr class=\"odd\">\n# > <td><code>^</code></td>\n# > <td>triangle_up marker</td>\n# > <td><code>x</code></td>\n# > <td>x marker</td>\n# > </tr>\n# > <tr class=\"even\">\n# > <td><code>&lt;</code></td>\n# > <td>triangle_left marker</td>\n# > <td><code>D</code></td>\n# > <td>diamond marker</td>\n# > </tr>\n# > <tr class=\"odd\">\n# > <td><code>&gt;</code></td>\n# > <td>triangle_right marker</td>\n# > <td><code>d</code></td>\n# > <td>thin_diamond marker</td>\n# > </tr>\n# > <tr class=\"even\">\n# > <td><code>1</code></td>\n# > <td>tri_down marker</td>\n# > <td><code>|</code></td>\n# > <td>vline marker</td>\n# > </tr>\n# > <tr class=\"odd\">\n# > <td><code>2</code></td>\n# > <td>tri_up marker</td>\n# > <td><code>_</code></td>\n# > <td>hline marker</td>\n# > </tr>\n# > </tbody>\n# > </table>\n# >\n# This second table gives the character codes for eight different colors.\n# Many more are possible but the color specification becomes more complex.\n# You can consult the web-based MatPlotLib documentation for further\n# details.\n#\n# > <table style=\"width:33%;\">\n# > <colgroup>\n# > <col style=\"width: 16%\" />\n# > <col style=\"width: 16%\" />\n# > </colgroup>\n# > <thead>\n# > <tr class=\"header\">\n# > <th>character</th>\n# > <th>color</th>\n# > </tr>\n# > </thead>\n# > <tbody>\n# > <tr class=\"odd\">\n# > <td><code>b</code></td>\n# > <td>blue</td>\n# > </tr>\n# > <tr class=\"even\">\n# > <td><code>g</code></td>\n# > <td>green</td>\n# > </tr>\n# > <tr class=\"odd\">\n# > <td><code>r</code></td>\n# > <td>red</td>\n# > </tr>\n# > <tr class=\"even\">\n# > <td><code>c</code></td>\n# > <td>cyan</td>\n# > </tr>\n# > <tr class=\"odd\">\n# > <td><code>m</code></td>\n# > <td>magenta</td>\n# > </tr>\n# > <tr class=\"even\">\n# > <td><code>y</code></td>\n# > <td>yellow</td>\n# > </tr>\n# > <tr class=\"odd\">\n# > <td><code>k</code></td>\n# > <td>black</td>\n# > </tr>\n# > <tr class=\"even\">\n# > <td><code>w</code></td>\n# > <td>white</td>\n# > </tr>\n# > </tbody>\n# > </table>\n# >\n# Here are some examples of how these format specifiers can be used:\n#\n# ``` python\n# plot(x, y, 'ro')    # plots red circles\n# plot(x, y, 'ks-')   # plot black squares connected by black lines\n# plot(x, y, 'g^')    # plots green triangles that point up\n#\n# plot(x, y, 'k-')    # plots a black line between the points\n# plot(x, y, 'ms')    # plots magenta squares \n# ```\n#\n# You can also make two calls sequentially for added versatility. For\n# example, by sequentially calling the last two plot calls, the plot\n# produces magenta squares on top of black lines connecting the data\n# points.\n#\n# These format specifiers give rudimentary control of the plotting symbols\n# and lines. MatPlotLib provides much more precise and detailed control of\n# the plotting symbol size, line types, and colors using optional keyword\n# arguments instead of the plotting format strings introduced above. For\n# example, the following command creates a plot of large yellow diamond\n# symbols with blue edges connected by a green dashed line:\n#\n# ``` python\n# plt.plot(x, y, color='green', linestyle='dashed', marker='d', \n#      markerfacecolor='yellow', markersize=12, \n#      markeredgecolor='blue')\n# ```\n#\n# Try it out! The online MatPlotLib documentation provides all the\n# plotting format keyword arguments and their possible values.\n#\n# ### Error bars\n#\n# single: plots; error bars\n#\n# When plotting experimental data it is customary to include error bars\n# that indicate graphically the degree of uncertainty that exists in the\n# measurement of each data point. The MatPlotLib function `errorbar` plots\n# data with error bars attached. It can be used in a way that either\n# replaces or augments the `plot` function. Both vertical and horizontal\n# error bars can be displayed. The figure below illustrates the use of\n# error bars.\n#\n# <figure>\n# <img src=\"attachment:ExpDecay.png\" class=\"align-center\" alt=\"\" /><figcaption>Error Bars</figcaption>\n# </figure>\n#\n# When error bars are desired, you typically replace the `plot` function\n# with the `errorbar` function. The first two arguments of the `errorbar`\n# function are the `x` and `y` arrays to be plotted, just as for the\n# `plot` function. The keyword `fmt` *must be used* to specify the format\n# of the points to be plotted; the format specifiers are the same as for\n# `plot`. The keywords `xerr` and `yerr` are used to specify the $x$ and\n# $y$ error bars. Setting one or both of them to a constant specifies one\n# size for all the error bars. Alternatively, setting one or both of them\n# equal to an array that has the same length as the `x` and `y` arrays\n# allows you to give each data point an error bar with a different value.\n# If you only want $y$ error bars, then you should only specify the `yerr`\n# keyword and omit the `xerr` keyword. The color of the error bars is set\n# with the keyword `ecolor`.\n#\n# The code and plot below illustrates how to make error bars and was used\n# to make the above plot. Lines 14 and 15 contain the call to the\n# `errorbar` function. The $x$ error bars are all set to a constant value\n# of 0.75, meaning that the error bars extend 0.75 to the left and 0.75 to\n# the right of each data point. The $y$ error bars are set equal to an\n# array, which was read in from the data file containing the data to be\n# plotted, so each data point has a different $y$ error bar. By the way,\n# leaving out the `xerr` keyword argument in the `errorbar` function call\n# below would mean that only the $y$ error bars would be plotted.\n#\n# ``` python\n# import numpy as np\n# import matplotlib.pyplot as plt\n#\n# # read data from file\n# xdata, ydata, yerror = np.loadtxt('expDecayData.txt', unpack=True)\n#\n# # create theoretical fitting curve\n# x = np.linspace(0, 45, 128)\n# y = 1.1+ 3.0*x*np.exp(-(x/10.0)**2)\n#\n# # create plot\n# plt.figure(1, figsize = (6,4) )\n# plt.plot(x, y, 'b-', label=\"theory\")\n# plt.errorbar(xdata, ydata, fmt='ro', label=\"data\", \n#              xerr=0.75, yerr=yerror, ecolor='black')\n# plt.xlabel('x')\n# plt.ylabel('transverse displacement')\n# plt.legend(loc='upper right')\n#\n# # save plot to file\n# plt.savefig('ExpDecay.pdf')\n#\n# # display plot on screen\n# plt.show()\n# ```\n#\n# We have more to say about the `errorbar` function in the sections on\n# logarithmic plots. But the brief introduction given here should suffice\n# for making most plots not involving logarithmic axes.\n#\n# ### Setting plotting limits and excluding data\n#\n# It turns out that you often want to restrict the range of numerical\n# values over which you plot data or functions. In these cases you may\n# need to manually specify the plotting window or, alternatively, you may\n# wish to exclude data points that are outside some set of limits. Here we\n# demonstrate methods for doing this.\n#\n# #### Setting plotting limits\n#\n# single: plots; setting axis limits\n#\n# Suppose you want to plot the tangent function over the interval from 0\n# to 10. The following script offers an straightforward first attempt.\n#\n# ``` python\n# import numpy as np\n# import matplotlib.pyplot as plt\n#\n# theta = np.arange(0.01, 10., 0.04)\n# ytan = np.tan(theta)\n#\n# plt.figure()\n# plt.plot(theta, ytan)\n# plt.show()\n# ```\n#\n# <figure>\n# <img src=\"attachment:plotLimits1.png\" class=\"align-center\" alt=\"\" />\n# </figure>\n#\n# The resulting plot, shown above, doesn't quite look like what you might\n# have expected for $\\tan\\theta$ *vs* $\\theta$. The problem is that\n# $\\tan\\theta$ diverges at $\\theta = \\pi/2, 3\\pi/2, 5\\pi/2, ...$, which\n# leads to large spikes in the plots as values in the `theta` array come\n# near those values. Of course, we don't want the plot to extend all the\n# way out to $\\pm\\infty$ in the $y$ direction, nor can it. Instead, we\n# would like the plot to extend far enough that we get the idea of what is\n# going on as $y\\rightarrow\\pm\\infty$, but we would still like to see the\n# behavior of the graph near $y=0$. We can restrict the range of `ytan`\n# values that are plotted using the MatPlotLib function `ylim`, as we\n# demonstrate in the script below.\n#\n# ``` python\n# import numpy as np\n# import matplotlib.pyplot as plt\n#\n# theta = np.arange(0.01, 10., 0.04)\n# ytan = np.tan(theta)\n#\n# plt.figure()\n# plt.plot(theta, ytan)\n# plt.ylim(-8, 8)         # restricts range of y axis from -8 to +8\n# plt.axhline(color=\"gray\", zorder=-1)\n#\n# plt.show()\n# ```\n#\n# The figure produced by this script is shown below. The plot now looks\n# much more like the familiar $\\tan\\theta$ function we know. We have also\n# include a call to the `axline` function to create an $x$ axis.\n#\n# <figure>\n# <img src=\"attachment:plotLimits2.png\" class=\"align-center\" alt=\"\" /><figcaption>Tangent function (with spurious lines)</figcaption>\n# </figure>\n#\n# The vertical blue lines at $\\theta = \\pi/2, 3\\pi/2, 5\\pi/2$ should not\n# appear in a plot of $\\tan\\theta$ *vs* $\\theta$. However, they do appear\n# because the `plot` function simply draws lines between the data points\n# in the `x`-`y` arrays provided in its arguments. Thus, `plot` draws a\n# line between the very large positive and negative `ytan` values\n# corresponding to the `theta` values on either side of $\\pi/2$ where\n# $\\tan\\theta$ diverges to $\\pm\\infty$. It would be nice to exclude that\n# line.\n#\n# #### Masked arrays\n#\n# single: plots; masked arrays single: masked arrays\n#\n# We can exclude the data points near $\\theta = \\pi/2, 3\\pi/2, 5\\pi/2$ in\n# the above plot, and thus avoid drawing the nearly vertical lines at\n# those points, using NumPy's *masked array* feature. The code below shows\n# how this is done and produces the graph below. The masked array feature\n# is implemented in line 6 with a call to NumPy's `masked_where` function\n# in the sub-module `ma` (masked array). Therefore, it is called by\n# writing `np.ma.masked_where`. The `masked_where` function works as\n# follows. The first argument sets the condition for masking elements of\n# the array, which is specified by the second argument. In this case, the\n# function says to mask all elements of the array `ytan` (the second\n# argument) where the absolute value of `ytan` is greater than 20. The\n# result is set equal to `ytanM`. When `ytanM` is plotted, MatPlotLib's\n# `plot` function omits all masked points from the plot. You can think of\n# it as the `plot` function lifting the pen that is drawing the line in\n# the plot when it comes to the masked points in the array `ytanM`.\n#\n# <figure>\n# <img src=\"attachment:plotLimits3.png\" class=\"align-center\" alt=\"\" /><figcaption>Tangent function</figcaption>\n# </figure>\n#\n# ``` python\n# import numpy as np\n# import matplotlib.pyplot as plt\n#\n# theta = np.arange(0.01, 10., 0.04)\n# ytan = np.tan(theta)\n# ytanM = np.ma.masked_where(np.abs(ytan)>20., ytan)\n#\n# plt.figure()\n# plt.plot(theta, ytanM)\n# plt.ylim(-8, 8)\n# plt.axhline(color=\"gray\", zorder=-1)\n#\n# plt.show()\n# ```\n#\n# ### Subplots\n#\n# single: plots; subplots\n#\n# Often you want to create two or more graphs and place them next to one\n# another, generally because they are related to each other in some way.\n# The plot below shows an example of such a plot. In the top graph,\n# $\\tan\\theta$ and $\\sqrt{(8/\\theta)^2-1}$ *vs* $\\theta$ are plotted. The\n# two curves cross each other at the points where\n# $\\tan\\theta=\\sqrt{(8/\\theta)^2-1}$. In the bottom $\\cot\\theta$ and\n# $-\\sqrt{(8/\\theta)^2-1}$ *vs* $\\theta$ are plotted. These two curves\n# cross each other at the points where\n# $\\cot\\theta=-\\sqrt{(8/\\theta)^2-1}$.\n#\n# <figure>\n# <img src=\"attachment:subplotDemo.png\" class=\"align-center\" alt=\"\" /><figcaption>Crossing functions</figcaption>\n# </figure>\n#\n# The code that produces this plot is provided below.\n#\n# ``` python\n# import numpy as np\n# import matplotlib.pyplot as plt\n#\n# theta = np.arange(0.01, 8., 0.04)\n# y = np.sqrt((8./theta)**2-1.)\n# ytan = np.tan(theta)\n# ytan = np.ma.masked_where(np.abs(ytan)>20., ytan)\n# ycot = 1./np.tan(theta)\n# ycot = np.ma.masked_where(np.abs(ycot)>20., ycot)\n#\n# plt.figure(1)\n#\n# plt.subplot(2, 1, 1)\n# plt.plot(theta, y)\n# plt.plot(theta, ytan)\n# plt.ylim(-8, 8)\n# plt.axhline(color=\"gray\", zorder=-1)\n# plt.axvline(x=np.pi/2., color=\"gray\", linestyle='--', zorder=-1)\n# plt.axvline(x=3.*np.pi/2., color=\"gray\", linestyle='--', zorder=-1)\n# plt.axvline(x=5.*np.pi/2., color=\"gray\", linestyle='--', zorder=-1)\n# plt.xlabel(\"theta\")\n# plt.ylabel(\"tan(theta)\")\n#\n# plt.subplot(2, 1, 2)\n# plt.plot(theta, -y)\n# plt.plot(theta, ycot)\n# plt.ylim(-8, 8)\n# plt.axhline(color=\"gray\", zorder=-1)\n# plt.axvline(x=np.pi, color=\"gray\", linestyle='--', zorder=-1)\n# plt.axvline(x=2.*np.pi, color=\"gray\", linestyle='--', zorder=-1)\n# plt.xlabel(\"theta\")\n# plt.ylabel(\"cot(theta)\")\n#\n# plt.show()\n# ```\n#\n# The function `subplot`, called on lines 13 and 24, creates the two\n# subplots in the above figure. `subplot` has three arguments. The first\n# specifies the number of rows that the figure space is to be divided\n# into; on line 13, it's two. The second specifies the number of columns\n# that the figure space is to be divided into; on line 13, it's one. The\n# third argument specifies which rectangle the will contain the plot\n# specified by the following function calls. Line 13 specifies that the\n# plotting commands that follow will be act on the first box. Line 24\n# specifies that the plotting commands that follow will be act on the\n# second box.\n#\n# We have also labeled the axes and included dashed vertical lines at the\n# values of $\\theta$ where $\\tan\\theta$ and $\\cot\\theta$ diverge.\n#\n# Logarithmic plots\n# -----------------\n#\n# single: plots; logarithmic axes\n#\n# Data sets can span many orders of magnitude from fractional quantities\n# much smaller than unity to values much larger than unity. In such cases\n# it is often useful to plot the data on logarithmic axes.\n#\n# ### Semi-log plots\n#\n# single: plots; semi-log\n#\n# For data sets that vary exponentially in the independent variable, it is\n# often useful to use one or more logarithmic axes. Radioactive decay of\n# unstable nuclei, for example, exhibits an exponential decrease in the\n# number of particles emitted from the nuclei as a function of time. In\n# the plot below, for example, we show the decay of the radioactive\n# isotope Phosphorus-32 over a period of 6 months, where the radioactivity\n# is measured once each week. Starting at a decay rate of nearly $10^4$\n# electrons (counts) per second, the decay rate diminishes to only about 1\n# count per second after about 6 months or 180 days. If we plot counts per\n# second as a function of time on a normal plot, as we have done in the\n# plot on the left below, then the count rate is indistinguishable from\n# zero after about 100 days. On the other hand, if we use a logarithmic\n# axis for the count rate, as we have done in the plot on the right below,\n# then we can follow the count rate well past 100 days and can readily\n# distinguish it from zero. Moreover, if the data vary exponentially in\n# time, then the data will fall along a straight line, as they do for the\n# case of radioactive decay.\n#\n# <figure>\n# <img src=\"attachment:semilogDemo.png\" class=\"align-center\" alt=\"\" /><figcaption>Semi-log plotting</figcaption>\n# </figure>\n#\n# MatPlotLib provides two functions for making semi-logarithmic plots,\n# `semilogx` and `semilogy`, for creating plots with logarithmic $x$ and\n# $y$ axes, with linear $y$ and $x$ axes, respectively. We illustrate\n# their use in the program below, which made the above plots.\n#\n# ``` python\n# import numpy as np\n# import matplotlib.pyplot as plt\n#\n# # read data from file\n# time, counts, unc = np.loadtxt('SemilogDemo.txt', unpack=True)\n#\n# # create theoretical fitting curve\n# tau = 20.2      # Phosphorus-32 half life = 14 days; tau = t_half/ln(2)\n# N0 = 8200.       # Initial count rate (per second)\n# t = np.linspace(0, 180, 128)\n# N = N0 * np.exp(-t/tau)\n#\n# # create plot\n# plt.figure(1, figsize = (10,4) )\n#\n# plt.subplot(1, 2, 1)\n# plt.plot(t, N, 'b-', label=\"theory\")\n# plt.plot(time, counts, 'ro', label=\"data\")\n# plt.xlabel('time (days)')\n# plt.ylabel('counts per second')\n# plt.legend(loc='upper right')\n#\n# plt.subplot(1, 2, 2)\n# plt.semilogy(t, N, 'b-', label=\"theory\")\n# plt.semilogy(time, counts, 'ro', label=\"data\")\n# plt.xlabel('time (days)')\n# plt.ylabel('counts per second')\n# plt.legend(loc='upper right')\n#\n# plt.tight_layout()\n#\n# # display plot on screen\n# plt.show()\n# ```\n#\n# The `semilogx` and `semilogy` functions work the same way as the `plot`\n# function. You just use one or the other depending on which axis you want\n# to be logarithmic.\n#\n# #### The `tight_layout()` function\n#\n# single: MatPlotLib functions; tight\\_layout\n#\n# You may have noticed the `tight_layout()` function, called without\n# arguments on line 30 of the program. This is a convenience function that\n# adjusts the sizes of the plots to make room for the axes labels. If it\n# is not called, the $y$-axis label of the right plot runs into the left\n# plot. The `tight_layout()` function can also be useful in graphics\n# windows with only one plot sometimes.\n#\n# ### Log-log plots\n#\n# single: plots; log-log\n#\n# MatPlotLib can also make log-log or double-logarithmic plots using the\n# function `loglog`. It is useful when both the $x$ and $y$ data span many\n# orders of magnitude. Data that are described by a power law $y=Ax^b$,\n# where $A$ and $b$ are constants, appear as straight lines when plotted\n# on a log-log plot. Again, the `loglog` function works just like the\n# `plot` function but with logarithmic axes.\n#\n# More advanced graphical output\n# ------------------------------\n#\n# The plotting methods introduced in the previous sections are perfectly\n# adequate for basic plotting and are therefore recommended for simple\n# graphical output. Here, we introduce an alternative syntax that\n# harnesses the full power of MatPlotLib. It gives the user more options\n# and greater control. Perhaps the most efficient way to learn this\n# alternative syntax is to look at an example. The figure below\n# illustrating `MultPlotDemo` is produced by the following code:\n#\n# <figure>\n# <img src=\"attachment:MultPlotDemo.png\" class=\"align-center\" width=\"320\" alt=\"\" /><figcaption>Mulitple plots in the same window</figcaption>\n# </figure>\n#\n#     # Demonstrates the following:\n#     #     plotting logarithmic axes\n#     #     user-defined functions\n#     #     \"where\" function, NumPy array conditional\n#\n#     import numpy as np\n#     import matplotlib.pyplot as plt\n#\n#     # Define the sinc function, with output for x=0 defined\n#     # as a special case to avoid division by zero. The code\n#     # below defining the sinc function is developed and\n#     # explained in Chapter 7, Section 1.\n#     def s(x):\n#       a = np.where(x==0., 1., np.sin(x)/x)\n#       return a\n#\n#     # create arrays for plotting\n#     x = np.arange(0., 10., 0.1)\n#     y = np.exp(x)\n#\n#     t = np.linspace(-10., 10., 100)\n#     z = s(t)\n#\n#     # create a figure window\n#     fig = plt.figure(1, figsize=(9,8))\n#\n#     # subplot: linear plot of exponential\n#     ax1 = fig.add_subplot(2,2,1)\n#     ax1.plot(x, y)\n#     ax1.set_xlabel('time (ms)')\n#     ax1.set_ylabel('distance (mm)')\n#     ax1.set_title('exponential')\n#\n#     # subplot: semi-log plot of exponential\n#     ax2 = fig.add_subplot(2,2,2)\n#     ax2.plot(x, y)\n#     ax2.set_yscale('log')\n#     ax2.set_xlabel('time (ms)')\n#     ax2.set_ylabel('distance (mm)')\n#     ax2.set_title('exponential')\n#\n#     # subplot: wide subplot of sinc function\n#     ax3 = fig.add_subplot(2,1,2)\n#     ax3.plot(t, z, 'r')\n#     ax3.axhline(color='gray')\n#     ax3.axvline(color='gray')\n#     ax3.set_xlabel('angle (deg)')\n#     ax3.set_ylabel('electric field')\n#     ax3.set_title('sinc function')\n#\n#     # Adjusts white space to avoid collisions between subplots\n#     fig.tight_layout()\n#     plt.show()\n#\n# After defining several arrays for plotting, the above program opens a\n# figure window in line 23 with the statement :\n#\n#     fig = plt.figure(figsize=(9,8))\n#\n# The MatPlotLib statement above creates a **Figure** object, assigns it\n# the name `fig`, and opens a blank figure window. Thus, just as we give\n# lists, arrays, and numbers variable names (*e.g.* `a = [1, 2, 5, 7]`,\n# `dd = np.array([2.3, 5.1, 3.9])`, or `st = 4.3`), we can give a figure\n# object and the window in creates a name: here it is `fig`. In fact we\n# can use the `figure` function to open up multiple figure objects with\n# different figure windows. The statements :\n#\n#     fig1 = plt.figure()\n#     fig2 = plt.figure()\n#\n# open up two separate windows, one named `fig1` and the other `fig2`. We\n# can then use the names `fig1` and `fig2` to plot things in either\n# window. The `figure` function need not take any arguments if you are\n# satisfied with the default settings such as the figure size and the\n# background color. On the other hane, by supplying one or more keyword\n# arguments, you can customize the figure size, the background color, and\n# a few other properties. For example, in the program listing (line 23),\n# the keyword argument `figsize` sets the width and height of the figure\n# window; the default size is `(8, 6)`; in our program we set it to\n# `(9, 8)`, which is a bit wider and higher than the default size. In the\n# example above, we also choose to open only a single window, hence the\n# single `figure` call.\n#\n# The `fig.add_subplot(2,2,1)` in line 30 is a MatPlotLib function that\n# divides the figure window into 2 rows (the first argument) and 2 columns\n# (the second argument). The third argument creates a subplot in the first\n# of the 4 subregions (*i.e.* of the 2 rows $\\times$ 2 columns) created by\n# the `fig.add_subplot(2,2,1)` call. To see how this works, type the\n# following code into a Python module and run it:\n#\n#     import numpy as np\n#     import matplotlib.pyplot as plt\n#\n#     fig = plt.figure(figsize=(9,8))\n#     ax1 = fig.add_subplot(2,2,1)\n#\n#     plt.show()\n#\n# You should get a figure window with axes drawn in the upper left\n# quadrant. The `fig.` prefix used with the `add_subplot(2,2,1)` function\n# directs Python to draw these axes in the figure window named `fig`. If\n# we had opened two figure windows, changing the prefix to correspond to\n# the name of one or the other of the figure windows would direct the axes\n# to be drawn in the appropriate window. Writing\n# `ax1 = fig.add_subplot(2,2,1)` assigns the name ax1 to the axes in the\n# upper left quadrant of the figure window.\n#\n# The `ax1.plot(x, y)` in line 27 directs Python to plot the\n# previously-defined `x` and `y` arrays onto the axes named `ax1`. The\n# `ax2 = fig.add_subplot(2,2,2)` draws axes in the second, or upper right,\n# quadrant of the figure window. The `ax3 = fig.add_subplot(2,1,2)`\n# divides the figure window into 2 rows (first argument) and 1 column\n# (second argument), creates axes in the second or these two sections, and\n# assigns those axes (*i.e.* that subplot) the name `ax3`. That is, it\n# divides the figure window into 2 halves, top and bottom, and then draws\n# axes in the half number 2 (the third argument), or lower half of the\n# figure window.\n#\n# You may have noticed in above code that some of the function calls are a\n# bit different from those used before: `xlabel(’time (ms)’)` becomes\n# `set_xlabel(’time (ms)’)`, `title(’exponential’)` becomes\n# `set_title(’exponential’)`, *etc.*\n#\n# The call `ax2.set_yscale('log')` sets the $y$-axes in the second plot to\n# be logarithmic, thus creating a semi-log plot. Creating properly-labeled\n# logarthmic axes like this is more straightforward with the advanced\n# syntax illustrated in the above example.\n#\n# Using the prefixes `ax1`, `ax2`, or `ax3`, direct graphical instructions\n# to their respective subplots. By creating and specifying names for the\n# different figure windows and subplots within them, you access the\n# different plot windows more efficiently. For example, the following code\n# makes four identical subplots in a single figure window using a `for`\n# loop.\n#\n# ``` ipython\n# In [1]: fig = figure()\n#\n# In [2]: ax1 = fig.add_subplot(221)\n#\n# In [3]: ax2 = fig.add_subplot(222)\n#\n# In [4]: ax3 = fig.add_subplot(223)\n#\n# In [5]: ax4 = fig.add_subplot(224)\n#\n# In [6]: for ax in [ax1, ax2, ax3, ax4]:\n#    ...:     ax.plot([3,5,8],[6,3,1])\n#\n# In [7]: show()\n# ```\n#\n# Exercises\n# ---------\n#\n# 1.  Plot the function $y=3x^2$ for $-1 \\le x \\le 3$ as a continuous\n#     line. Include enough points so that the curve you plot appears\n#     smooth. Label the axes $x$ and $y$.\n#\n# 2.  Plot the following function for $-15 \\le x \\le 15$:\n#\n#     $$y = \\frac{\\cos x}{1+\\frac{1}{5}x^2}$$\n#\n#     Include enough points so that the curve you plot appears smooth.\n#     Label the axes $x$ and $y$.\n#\n# 3.  Plot the functions $\\sin x$ and $\\cos x$ *vs* $x$ on the same plot\n#     with $x$ going from $-\\pi$ to $\\pi$. Make sure the limits of\n#     $x$-axis do not extend beyond the limits of the data. Plot $\\sin x$\n#     in the color green and $\\cos x$ in the color black and include a\n#     legend to label the two curves. Place the legend within the plot,\n#     but such that it does not cover either of the sine or cosine traces.\n#\n# 4.  Create a data file with the data shown below.\n#\n#     1.  Read the data into Python program and plot $t$ *vs* $y$ using\n#         circles for data points with error bars. Use the data in the\n#         `dy` column as the error estimates for the $y$ data. Label the\n#         horizontal and vertical axes \"time (s)\" and \"position (cm)\".\n#\n#     2.  On the same graph, plot the function below as a smooth line.\n#         Make the line pass *behind* the data points.\n#\n#         $$y(t) = \\left[3 + \n#                \\frac{1}{2}\\sin\\frac{\\pi t}{5}\\right]\n#                t\\, e^{-t/10}$$\n#\n#             Data for Exercise 4\n#             Date: 16-Aug-2013\n#             Data taken by Lauren and John\n#\n#              t      d       dy\n#              1.0    2.94    0.7\n#              4.5    8.29    1.2\n#              8.0    9.36    1.2\n#             11.5   11.60    1.4\n#             15.0    9.32    1.3\n#             18.5    7.75    1.1\n#             22.0    8.06    1.2\n#             25.5    5.60    1.0\n#             29.0    4.50    0.8\n#             32.5    4.01    0.8\n#             36.0    2.62    0.7\n#             39.5    1.70    0.6\n#             43.0    2.03    0.6\n#\n# 5.  Use MatPlotLib's function `hist` along with NumPy's function's\n#     `random.rand` and `random.randn` to create the histogram graphs\n#     shown in Fig. `fig-randhistos`\n#\n# 6.  Plot force *vs* distance with error bars using the following data:\n#\n#         d=np.array([0.38, 0.64, 0.91, 1.26, 1.41, 1.66, 1.90, 2.18])\n#         f=np.array([1.4, 1.65, 3.0, 3.95, 4.3, 5.20, 6.85, 7.4])\n#         df=np.array([ 0.4, 0.5, 0.4, 0.5, 0.6, 0.5, 0.5, 0.4])\n#\n#     Your plot should also include a visual straight \"best fit\" to the\n#     data as well as visual \"fits\" that give the smallest and largest\n#     slopes consistent with the data. Note, you only need two points to\n#     define a straight line so the straight lines you draw on the plot\n#     should be arrays of length 2 and no longer. All of your fitted lines\n#     should lie *behind* the data. Try to make your plot look like the\n#     one below. *In addition*, add a legend to your plot the gives the\n#     slope with its uncertainty obtained from your visual fits to the\n#     data.\n#\n#     <figure>\n#     <img src=\"attachment:LinearData.png\" class=\"align-center\" alt=\"\" />\n#     </figure>\n#\n#     The web page <http://matplotlib.org/api/pyplot_summary.html> gives a\n#     summary of the main plotting commands available in MatPlotLib. The\n#     two important ones here are `plot` and `errorbar`, which make\n#     regular plots and plots with error bars, respectively. You will find\n#     the following keyword arguments useful: `yerr`, `ls`, `marker`,\n#     `mfc`, `mec`, `ms`, and `ecolor`, which you can find described by\n#     clicking on the `errorbar` function link on the web page cited\n#     above.\n#\n# 7.  The data file below shows data obtained for the displacement\n#     (position) *vs* time of a falling object, together with the\n#     estimated uncertainty in the displacement.\n#\n#     >     Measurements of fall velocity vs time\n#     >     Taken by A.P. Crawford and S.M. Torres\n#     >     19-Sep-13        \n#     >     time (s)    position (m)    uncertainty (m)\n#     >      0.0            0.0             0.04\n#     >      0.5            1.3             0.12\n#     >      1.0            5.1             0.2\n#     >      1.5           10.9             0.3\n#     >      2.0           18.9             0.4\n#     >      2.5           28.7             0.4\n#     >      3.0           40.3             0.5\n#     >      3.5           53.1             0.6\n#     >      4.0           67.5             0.6\n#     >      4.5           82.3             0.6\n#     >      5.0           97.6             0.7\n#     >      5.5          113.8             0.7\n#     >      6.0          131.2             0.7\n#     >      6.5          148.5             0.7\n#     >      7.0          166.2             0.7\n#     >      7.5          184.2             0.7\n#     >      8.0          201.6             0.7\n#     >      8.5          220.1             0.7\n#     >      9.0          238.3             0.7\n#     >      9.5          256.5             0.7\n#     >     10.0          275.6             0.8\n#\n#     1.  Use these data to calculate the velocity and acceleration (in a\n#         Python program `.py` file), together with their uncertainties\n#         propagated from the displacement *vs* time uncertainties. Be\n#         sure to calculate time arrays corresponding the midpoint in time\n#         between the two displacements or velocities for the velocity and\n#         acceleration arrays, respectively.\n#     2.  In a single window frame, make three vertically stacked plots of\n#         the displacement, velocity, and acceleration *vs* time. Show the\n#         error bars on the different plots. Make sure that the time axes\n#         of all three plots cover the same range of times. Why do the\n#         relative sizes of the error bars grow progressively greater as\n#         one progresses from displacement to velocity to acceleration?\n\n# %%\n", "meta": {"hexsha": "9f9b2a58a223d80a28291c92734a77766b0fde38", "size": 46092, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks/chap5_plot.py", "max_stars_repo_name": "lorenghoh/pyman", "max_stars_repo_head_hexsha": "9b4ddd52c5577fc85e2601ae3128f398f0eb673c", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/chap5_plot.py", "max_issues_repo_name": "lorenghoh/pyman", "max_issues_repo_head_hexsha": "9b4ddd52c5577fc85e2601ae3128f398f0eb673c", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "notebooks/chap5_plot.py", "max_forks_repo_name": "lorenghoh/pyman", "max_forks_repo_head_hexsha": "9b4ddd52c5577fc85e2601ae3128f398f0eb673c", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.5300171527, "max_line_length": 144, "alphanum_fraction": 0.6684240215, "include": true, "reason": "import numpy", "num_tokens": 13251, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46879064146934857, "lm_q2_score": 0.17328820806405806, "lm_q1q2_score": 0.08123589021742372}}
{"text": "# -*- coding: utf-8 -*-\n# ---\n# jupyter:\n#   jupytext:\n#     formats: ipynb,py:percent\n#     text_representation:\n#       extension: .py\n#       format_name: percent\n#       format_version: '1.3'\n#       jupytext_version: 1.13.3\n#   kernelspec:\n#     display_name: tcv-x21\n#     language: python\n#     name: tcv-x21\n# ---\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# # Post-processing a GRILLIX simulation\n#\n# This notebook demonstrates how to perform the post-processing analysis for\n# a GRILLIX simulation, contained in the `sample_data` folder.\n#\n# To limit the repository size, only 5 snapshot write-outs are provided. The sample data is provided primarily to demonstrate the\n# method by which you can generate a standard NetCDF file for another simulation,\n# to perform an equivalent validation.\n#\n# Analysis routines are provided in the `tcvx21/grillix_post` folder.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nimport tcvx21\n\n# %reload_ext autoreload\n# %autoreload 2\n# %matplotlib inline\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport xarray as xr\nfrom pathlib import Path\nfrom tcvx21.units_m import Quantity, Dimensionless, convert_xarray_to_quantity\nfrom tcvx21.file_io.json_io_m import read_from_json\n\nimport tcvx21.grillix_post as grillix\nfrom tcvx21 import test_session\n\nplt.style.use(tcvx21.style_sheet)\n\nplt.rcParams.update({\"mathtext.default\": \"regular\"})\nplt.rcParams[\"figure.facecolor\"] = \"white\"\nxr.set_options(keep_attrs=True)\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nfile_path = tcvx21.sample_data\ntime_slice = slice(None)\n\nfile_path = Path(file_path)\nassert file_path.exists()\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ## Setting up an interface to the data\n#\n# We start by reading in the basic simulation data. For GRILLIX, this is\n#\n# 1. Grid: the $R,Z$ grid used for the simulation (assumed to be axisymmetric).\n#    Since we trim our grid at a limiting flux-surface, the data is stored as unstructured\n#    $(R, Z, value)$ column data. The grid allows us to map this to a matrix form $value(R, Z)$, which is needed\n#    for plotting and analysis.\n# 2. Normalisation: a set of `pint.Quantity` values which allows us to go from\n#    normalised values to SI values. The `pint.Quantity` class is highly capable,\n#    allowing unit tracking through basic operations, and unit conversion.\n# 3. `xr.Dataset` snaps: an interface to the GRILLIX snapshot data. The xarray\n#    module interfaces with dask to provide a memory-light interface to very\n#    large files. It is similar to a `pandas.DataFrame`.\n# 4. Equi: an interface to the equilibrium file, providing data about the magnetic\n#    field and penalisation (which is how GRILLIX sets boundary conditions). The\n#    `flip_z` parameter is used to invert the toroidal field direction.\n#\n# To limit the size of the tcvx21 repository, we provide only sample data over a few snapshots\n# of a low-resolution (2mm) case.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\ngrid = grillix.components.Grid(file_path / \"vgrid.nc\")\nnorm = grillix.components.Normalisation.initialise_from_normalisation_file(\n    file_path / \"physical_parameters.nml\"\n)\nsnaps = grillix.components.read_snaps_from_file(\n    file_path, norm, time_slice=slice(None), all_planes=True\n)\nequi = grillix.components.Equi(\n    file_path / \"TCV_ortho.nc\", file_path / \"pen_metainfo.nc\", flip_z=True\n)\n\nparameter_filepath = grillix.filepath_resolver(file_path, \"params.in\")\nparams = grillix.components.convert_params_filepaths(\n    parameter_filepath, grillix.components.read_fortran_namelist(parameter_filepath)\n)\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ## Data extraction via \"lineouts\"\n#\n# Now that we have the interface prepared, we want to extract values at the\n# set of experimental observable positions. We do this via \"lineouts\", which\n# provide an efficient way to get points at specific $R,Z$ positions.\n#\n# We also need to be able to map from a flux-surface label to the\n# $R^u - R^u_{sep}$ coordinate. We do this via the OutboardMidplaneMap.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nn_points = 500\nomp_map = grillix.lineouts.OutboardMidplaneMap(grid, equi, norm)\nomp = grillix.lineouts.outboard_midplane_chord(grid, equi, n_points=500)\nlfs = grillix.lineouts.penalisation_contour(\n    grid, equi, level=0.0, contour_index=0, n_points=n_points\n)\nhfs = grillix.lineouts.penalisation_contour(\n    grid, equi, level=0.0, contour_index=1, n_points=n_points\n)\nts = grillix.lineouts.thomson_scattering(\n    grid, equi, tcvx21.thomson_coords_json, n_points=n_points\n)\nrdpa = grillix.lineouts.rdpa(grid, equi, omp_map, norm, tcvx21.rdpa_coords_json)\nxpt = grillix.lineouts.xpoint(grid, equi, norm)\n\nlineouts = {\"omp\": omp, \"lfs\": lfs, \"hfs\": hfs, \"ts\": ts, \"rdpa\": rdpa, \"xpt\": xpt}\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# We also want to be able to calculate parallel gradients. In GRILLIX, this\n# is done via the FCI method. A simplified trace-and-interpolate method\n# is demonstrated here. Note that since we're interpolating in Python,\n# this is very slow!\n#\n# To speed things up a little, we trace only once per lineout, and only\n# for the lineouts where we need parallel gradients.\n#\n# (Unfortunately, dask-based parallelism raises a strange `CancelledError` when\n# these loops are attempted to be parallelized)\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\n# %%time\ngrillix.observables.initialise_lineout_for_parallel_gradient(\n    lfs,\n    grid,\n    equi,\n    norm,\n    params[\"params_grid\"][\"npol\"],\n    stored_trace=file_path / f\"lfs_trace_{n_points}.nc\",\n)\n# We don't compute the heat flux for the HFS, so can save time by not tracing for it\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# As a sanity check, it's always a good idea to plot things before we perform the\n# analysis.\n#\n# The lfs and hfs lineouts in GRILLIX are defined at positions which don't exactly\n# correspond to the physical wall. This is because GRILLIX uses a smooth\n# penalisation characteristic function. The lfs and hfs positions are defined as\n# the surface where we *start* to apply boundary conditions. For more details\n# on this method, see Stegmeir et al., 2019.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\ndivertor_ = read_from_json(tcvx21.divertor_coords_json)\n\n_, ax = plt.subplots(figsize=(10, 10))\nplt.contour(grid.r_s, grid.z_s, equi.normalised_flux_surface_label(grid.r_s, grid.z_s))\n\nplt.scatter(\n    lineouts[\"xpt\"].r_points,\n    lineouts[\"xpt\"].z_points,\n    s=1,\n    marker=\".\",\n    color=\"r\",\n    label=\"xpt\",\n)\nplt.scatter(\n    lineouts[\"rdpa\"].r_points,\n    lineouts[\"rdpa\"].z_points,\n    s=1,\n    marker=\"+\",\n    color=\"k\",\n    label=\"rdpa\",\n)\n\nfor key, lineout in lineouts.items():\n\n    if key in [\"rdpa\", \"xpt\"]:\n        continue\n\n    plt.plot(lineout.r_points, lineout.z_points, label=key, linewidth=2.5)\n\n    if hasattr(lineout, \"forward_lineout\"):\n        plt.plot(\n            lineout.forward_lineout.r_points,\n            lineout.forward_lineout.z_points,\n            label=f\"{key}+\",\n            linewidth=2.5,\n        )\n    if hasattr(lineout, \"reverse_lineout\"):\n        plt.plot(\n            lineout.reverse_lineout.r_points,\n            lineout.reverse_lineout.z_points,\n            label=f\"{key}-\",\n            linewidth=2.5,\n        )\n\nplt.legend()\nif equi.flipped_z:\n    ax.invert_yaxis()\nax.set_aspect(\"equal\")\n\nplt.plot(\n    divertor_[\"r_points\"] / equi.axis_r.values,\n    divertor_[\"z_points\"] / equi.axis_r.values * -1.0 if equi.flipped_z else 1.0,\n    color=\"k\",\n)\n\nif test_session:\n    plt.close(\"all\")\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ## Interfacing with the snaps\n#\n# The `snaps` object (an `xarray` labelled multi-dimensional array) provides\n# convenient access to the simulation data. We mostly focus on 1D lineouts\n# which can be compared to the experimental diagnostics, but we demonstrate\n# here the use of the analysis components to show the density perturbation.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nfig, ax = plt.subplots()\ngrid.shape(\n    snaps.density.isel(tau=0, phi=0) - snaps.density.mean(dim=(\"tau\", \"phi\"))\n).plot(shading=\"flat\")\n\nax.invert_yaxis()\nax.set_aspect(\"equal\")\nax.set_title(\"Density perturbation\")\n\nif test_session:\n    plt.close(\"all\")\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ## Demonstrating the lineout functionality\n#\n# Looks good! Next, let's test the lineout functionality. If you just want\n# normalised units, it's very easy using the xarray functionality.\n#\n# This one-liner has a lot going on, so let's unpack it\n# 1. `lineouts[omp]` requests the stored omp `Lineout`\n# 2. `.interpolate(` calls the interpolate method\n# 3. `snaps.density` requests the density stored in the snaps\n# 4. `).mean(dim='phi')` toroidally averages the result (since snaps.density has\n#    `phi, tau, points` dimensions, the lineout will have `phi, tau, interp_points`\n#    dimensions. We want to plot 2D, so average over `phi` to eliminate this dimension).\n# 5. `.plot()` is a thin wrapper of `matplotlib.pyplot.pcolormesh`, which automatically\n#    sets the x and y values of the plot from the xarray coordinates\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nlineouts[\"omp\"].interpolate(snaps.density).mean(dim=\"tau\").plot.contourf()\n\nif test_session:\n    plt.close(\"all\")\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# What about if we want this in SI units? Unfortunately, xarray isn't completely\n# compatible with `pint`, so we have to manually convert to `pint.Quantity` objects\n# and then set up the plotting manually.\n#\n# N.b. the underscore in the variable names is simply to indicate that these variables\n# are private -- i.e. they shouldn't be used in other routines (since Python\n# automatically promotes variables outside of functions to global scope. This\n# is something to be careful about in Jupyter notebooks).\n#\n# You can see that the result doesn't vary much with time,\n# but that's not surprising since 5 snaps is only 8 microseconds\n# of plasma time!\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\ntau_ = convert_xarray_to_quantity(snaps.tau).to(\"microseconds\")\ntau_ -= tau_[0]\n\nlineout_ = lineouts[\"omp\"]\nlineout_rho_ = equi.normalised_flux_surface_label(\n    lineout_.r_points, lineout_.z_points, grid=False\n)\nlineout_ru_ = convert_xarray_to_quantity(\n    omp_map.convert_rho_to_distance(lineout_rho_)\n).to(\"cm\")\n\nlineout_density_ = convert_xarray_to_quantity(\n    lineout_.interpolate(snaps.density).mean(dim=\"phi\")\n).to(\"1/m^3\")\n\nfig, ax = plt.subplots()\n\nim = ax.contourf(lineout_ru_, tau_, lineout_density_, shading=\"nearest\")\nplt.colorbar(im, ax=ax)\n\nax.set_ylabel(\"$\\\\tau$ [$\\\\mu$ s]\")\nax.set_xlabel(\"$R^u - R^u_{sep}$ [cm]\")\nax.set_title(\"OMP density [$1/m^3$]\")\n\nif test_session:\n    plt.close(\"all\")\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ## Synthetic diagnostics and bootstrap\n#\n# For observables which do not directly map to the simulation dynamic quantities,\n# we need a method to estimate what the measured value will be given plasma\n# parameters from the simulation. These can be roughly termed *synthetic\n# diagnostics*, although we use here only simple approximations. The functions\n# are stored in the `experimental_quantities_m.py` file.\n#\n# We show here how to calculate the skewness of the ion saturation current measured the low-field-side\n# target Langmuir probe array.\n#\n# This method also gives an estimate of the uncertainty of the statistical moment via the\n# bootstrap method. The bootstrap method takes several random samples of the signal (potentially\n# double-counting some points and omitting others) and then calculates the mean\n# and standard deviation of the statistical moments calculated from the random samples.\n# Strictly speaking it should be applied for purely random data, rather than correlated\n# data, but we use it nevertheless because it is a nice and simple approximation of the\n# finite-sampling error.\n#\n# For the mean, the bootstrap error is tiny, but for the higher-order statistical moments it\n# can be appreciable.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nlineout_ = lineouts[\"lfs\"]\nlineout_rho_ = equi.normalised_flux_surface_label(\n    lineout_.r_points, lineout_.z_points, grid=False\n)\nlineout_ru_ = convert_xarray_to_quantity(\n    omp_map.convert_rho_to_distance(lineout_rho_)\n).to(\"cm\")\n\nsound_speed_ = grillix.observables.sound_speed(\n    electron_temp=snaps.electron_temp, ion_temp=snaps.ion_temp, norm=norm\n)\n\njsat_ = grillix.observables.ion_saturation_current(\n    density=snaps.density, sound_speed=sound_speed_, norm=norm, wall_probe=True\n)\n\njsat_skew_, jsat_skew_err_ = tcvx21.analysis.compute_statistical_moment_with_bootstrap(\n    lineout_.interpolate(jsat_).rename({\"interp_points\": \"points\"}), moment=\"skew\"\n)\n\njsat_skew_ = convert_xarray_to_quantity(jsat_skew_)\njsat_skew_err_ = convert_xarray_to_quantity(jsat_skew_err_)\n\nfig, ax = plt.subplots()\n\nax.plot(lineout_ru_, jsat_skew_)\nax.fill_between(\n    lineout_ru_, jsat_skew_ + jsat_skew_err_, jsat_skew_ - jsat_skew_err_, alpha=0.5\n)\n\nax.set_xlabel(\"$R^u - R^u_{sep}$ [cm]\")\nax.set_title(\"LFS ion saturation current skewness\")\n\nif test_session:\n    plt.close(\"all\")\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ## Heat flux profile fitting\n#\n# A more involved synthetic diagnostic is the parallel heat flux to the\n# boundaries. From our anomalous heat transmission boundary conditions, we can\n# determine the heat flux to the boundaries as\n#\n# $q_{\\parallel,e} = \\frac{5}{2}n v_{\\parallel,e}T_e + \\frac{5}{2}n u_{E\\times B}T_e - \\chi_{\\parallel e,0} T_e^{5/2}\\nabla_\\parallel T_e$\n#\n# $q_{\\parallel,i} = \\frac{5}{2}n u_{\\parallel,i}T_i + \\frac{5}{2}n u_{E\\times B}T_i - \\chi_{\\parallel i,0} T_i^{5/2}\\nabla_\\parallel T_i$\n#\n# We can check the heat flux routines and the contribution from each component here.\n# Note that, unless the $E \\times B$ contribution is included, the heat flux\n# can become negative.\n#\n# You notice that there's a lot of terms in this equation.\n# $q_\\parallel$ isn't directly evolved in the code, so it has\n# a lower simulation hierarchy than other simpler observables.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nlineout_ = lineouts[\"lfs\"]\nlineout_rho_ = equi.normalised_flux_surface_label(\n    lineout_.r_points, lineout_.z_points, grid=False\n)\nlineout_ru_ = convert_xarray_to_quantity(\n    omp_map.convert_rho_to_distance(lineout_rho_)\n).to(\"cm\")\n\ndensity = lineout_.interpolate(snaps.density)\nion_velocity = lineout_.interpolate(snaps.velocity)\ncurrent = lineout_.interpolate(snaps.current)\nelectron_temp = lineout_.interpolate(snaps.electron_temp)\nelectron_temp_parallel_gradient = grillix.observables.compute_gradient_on_plane(\n    lineout_, snaps.electron_temp, plane=0\n)\nion_temp = lineout_.interpolate(snaps.ion_temp)\nion_temp_parallel_gradient = grillix.observables.compute_gradient_on_plane(\n    lineout_, snaps.ion_temp, plane=0\n)\neffective_parallel_exb = lineout_.interpolate(\n    grillix.observables.effective_parallel_exb_velocity(\n        grid, equi, norm, snaps.potential\n    )\n)\n\nq_e_conv = grillix.observables.heat_flux.electron_parallel_heat_convection(\n    density, electron_temp, ion_velocity, current, norm\n).isel(tau=0, phi=0)\nq_i_conv = grillix.observables.heat_flux.ion_parallel_heat_convection(\n    density, ion_temp, ion_velocity, norm\n).isel(tau=0, phi=0)\nq_e_cond = grillix.observables.heat_flux.electron_parallel_heat_conduction(\n    electron_temp, electron_temp_parallel_gradient, norm\n).isel(tau=0, phi=0)\nq_i_cond = grillix.observables.heat_flux.ion_parallel_heat_conduction(\n    ion_temp, ion_temp_parallel_gradient, norm\n).isel(tau=0, phi=0)\nq_e_exb = grillix.observables.heat_flux.exb_effective_parallel_heat_convection(\n    density, electron_temp, effective_parallel_exb, norm\n).isel(tau=0, phi=0)\nq_i_exb = grillix.observables.heat_flux.exb_effective_parallel_heat_convection(\n    density, ion_temp, effective_parallel_exb, norm\n).isel(tau=0, phi=0)\n\nq_par = grillix.observables.total_parallel_heat_flux(\n    density,\n    electron_temp,\n    electron_temp_parallel_gradient,\n    ion_temp,\n    ion_temp_parallel_gradient,\n    ion_velocity,\n    current,\n    effective_parallel_exb,\n    norm,\n).load()\n\nfig, ax = plt.subplots()\n\nax.plot(lineout_ru_, convert_xarray_to_quantity(q_e_conv), label=\"q_e_conv\")\nax.plot(lineout_ru_, convert_xarray_to_quantity(q_i_conv), label=\"q_i_conv\")\nax.plot(lineout_ru_, convert_xarray_to_quantity(q_e_cond), label=\"q_e_cond\")\nax.plot(lineout_ru_, convert_xarray_to_quantity(q_i_cond), label=\"q_i_cond\")\nax.plot(lineout_ru_, convert_xarray_to_quantity(q_i_exb), label=\"q_i_exb\")\nax.plot(lineout_ru_, convert_xarray_to_quantity(q_e_exb), label=\"q_e_exb\")\n\nax.plot(\n    lineout_ru_,\n    convert_xarray_to_quantity(q_par.isel(tau=0, phi=0)),\n    \"k--\",\n    label=\"total\",\n)\n\nax.legend()\n\nfig, ax = plt.subplots()\n_, lambda_q, _, _, _ = tcvx21.analysis.fit_eich_profile(\n    lineout_ru_, convert_xarray_to_quantity(q_par.mean(dim=(\"tau\", \"phi\"))), plot=True\n)\n\nprint(f\"lambda_q = {lambda_q[0]:4.3}±{lambda_q[1]:4.3}\")\n\nif test_session:\n    plt.close(\"all\")\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ## 2D data from the divertor volume\n#\n# As well as 1D profiles, we also have 2D profiles from the reciprocating\n# divertor probe array. Since the plasma can move relative to the wall,\n# we use $R^u - R^u_{omp}$ and $Z$ instead of the original $R, Z$ coordinates.\n# This means that our sample grid is not rectangular. We need to sample our\n# data on the unstructured grid.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nfrom scipy.interpolate import griddata\n\n\ndef plot_rdpa_field(rdpa_lineout, field, n_rsep=50, n_z=50):\n\n    x = rdpa_lineout.coords[\"Rsep\"]\n    y = rdpa_lineout.coords[\"Z\"]\n    assert x.shape == y.shape\n    z = rdpa_lineout.interpolate(field)\n\n    x_sample = np.linspace(x.min(), x.max(), num=n_rsep)\n    y_sample = np.linspace(y.min(), y.max(), num=n_z)\n    x_mesh, y_mesh = np.meshgrid(x_sample, y_sample)\n\n    z_sample = griddata(\n        points=(x.magnitude, y.magnitude),\n        values=z,\n        xi=(x_mesh.magnitude, y_mesh.magnitude),\n    )\n\n    z_sample *= z.norm\n\n    plt.pcolormesh(x_sample, y_sample, z_sample, shading=\"nearest\")\n    plt.colorbar()\n    plt.xlabel(\"$R^u - R^u_{sep}$\" + f\" [{x.units}]\")\n    plt.ylabel(f\"Z [{y.units}]\")\n    plt.title(f\"RDPA {z.name} [{z_sample.units}]\")\n\nplt.figure()\nplot_rdpa_field(lineouts[\"rdpa\"], snaps.electron_temp.mean(dim=(\"phi\", \"tau\")))\n\nif test_session:\n    plt.close(\"all\")\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ## Integral values for sources\n#\n# As well as profiles, we are also interested in integrals of the sources, to determine whether\n# we are using a source in the region of the experimental values.\n#\n# The sources in GRILLIX are given in the file tcvx21/grillix_analysis/sources_m.py. In GRILLIX we have\n# set a 'constant-power, constant-particle' source. That is, we actively adapt our electron-temperature\n# source to compensate for the power due to the particle source. This way, we inject a constant\n# 150kW exactly. This is deposited in the core as a temperature source. However, since the density source\n# also contributes to the power source we compensate for this by adding a negative temperature source\n# at the edge.\n#\n# $P = \\frac{3}{2}\\int n S_{T_e} + (T_e + T_i) S_n \\textrm{d}^3V$\n#\n# We are using\n# $S_n = n_0 / \\tau_0 \\hat{S}_n$\n# where\n#\n# $\\hat{S}_n = \\hat{S}_{n0} f_{S,n}(R,Z) = \\hat{S}_{n0} \\exp\\left[-\\left(\\rho(R,Z)^2 - \\rho_{cn}^2 \\right)/\\rho_{wn}^2\\right]$\n#\n# for $\\rho_{cn} = 0.815$ and $\\rho_{wn} =0.083$, and\n#\n# $S_{Te} = T_{0} / \\tau_0 \\left(\\frac{1}{\\hat{n}}\\hat{S}_{Te} - \\frac{\\hat{T}_e + \\hat{T}_i}{\\hat{n}} \\hat{S}_n \\right)$\n#\n# where\n#\n# $\\hat{S}_{Te} = \\hat{S}_{Te0} f_{S,Te}(R,Z) = \\hat{S}_{Te0} \\left(1 - \\mathcal{S}_3(\\rho, \\rho_{cT}, \\rho_{wT})\\right)$\n#\n# for $\\mathcal{S}_3(x, c, w)$ is a third-order [smoothstep](https://en.wikipedia.org/wiki/Smoothstep) function\n# centred at $c$ and of transition width $w$.\n#\n# This allows us to write\n#\n# $P = \\frac{3}{2}\\iiint n_0 \\hat{n} T_{0} / \\tau_0 \\left(\\frac{1}{\\hat{n}}\\hat{S}_{Te} - \\frac{\\hat{T}_e + \\hat{T}_i}{\\hat{n}} \\hat{S}_n \\right) + T_0(\\hat{T}_e + \\hat{T}_i) n_0 / \\tau_0 \\hat{S}_n \\textrm{d}^3V$\n#\n# $P= \\frac{3}{2}\\frac{n_0 T_0}{\\tau_0} \\iiint \\hat{S}_{Te} - (\\hat{T}_e + \\hat{T}_i) \\hat{S}_n + (\\hat{T}_e + \\hat{T}_i) \\hat{S}_n \\textrm{d}^3V$\n#\n# $P= \\frac{3}{2}\\frac{n_0 T_0}{\\tau_0} \\hat{S}_{Te0} \\iiint f_{S,Te}(R,Z) \\textrm{d}^3V$\n#\n# $P= \\frac{3}{2}\\frac{n_0 T_0}{\\tau_0} \\hat{S}_{Te0} \\mathcal{V}_w$\n#\n# That is, our power injection is determined entirely by our core electron temperature source.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\ngrillix.components.integrated_sources(grid, equi, norm, params, snaps)\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ## Iterating over all observables\n#\n# The final step to producing a standard NetCDF file for comparison is to iterate over each element\n# of the standard dictionary and fill the dictionary with results.\n# We then use the `RecordWriter`\n# to convert the standard dictionary into a NetCDF file.\n#\n# Since the raw data is very large (does not fit in memory), we do a two-step post-processing. In the first step, we iterate\n# over the time points in our raw data to compute the raw observables at the observable positions.\n# These are iteratively written to an intermediate processing file. In the second\n# step, we perform statistics over the processing file, calculating the data used for the validation\n# analysis.\n#\n# The first step is done with the `fill_work_file()` method of the `DataExtract` object.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nfrom tcvx21.grillix_post.work_file_writer_m import WorkFileWriter\n\n(file_path / \"processing_file.nc\").unlink(missing_ok=True)\n\ndata = WorkFileWriter(\n    file_path=file_path,\n    work_file=file_path / \"processing_file.nc\",\n    toroidal_field_direction=\"forward\",\n    make_work_file=True,\n)\n\ndata.fill_work_file()\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# In the second step, we need to make a `Record`, which is a NetCDF file formatted according\n# to the data template in `observables.json`.\n#\n# The validation is done in terms of statistical moments, rather than raw values.\n#\n# To compute statistical values and the uncertainty associated with it, we use the bootstrap\n# method. We take samples from all toroidal planes, and 1ms of data (500 snaps).\n#\n# We select values from the samples available for each observable point *with replacement*. This means that some points may be double-counted,\n# and some may be missed entirely.\n#\n# We repeat this a number of times, to generate a number of *tests*.\n#\n# Finally, we compute the median of the tests and a confidence interval -- which gives us a\n# robust estimator for the statistical moment and its uncertainty.\n#\n# The 65% and 95% confidence intervals are shown for the different statistical moments of $J_{sat}$\n#\n# Note that since we only have 5 time points here, the uncertainty is\n# higher than for the real result with 500 time points.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nimport xarray as xr\n\n\ndef Q(netcdf_array):\n    \"\"\"Converts netcdf arrays to Quantities\"\"\"\n    return Quantity(netcdf_array.values, netcdf_array.units)\n\n\ndef plot_region(x, y, dy, label):\n    plt.plot(x, y, label=label)\n    plt.fill_between(x, y - dy, y + dy, alpha=0.2)\n\n\nwork_file_path = file_path / \"processing_file.nc\"\nvalues = (\n    xr.open_dataset(work_file_path, group=\"LFS-LP/observables\")\n    .jsat.isel(tau=slice(-500, None))\n    .persist()\n)\nRsep = Q(xr.open_dataset(work_file_path, group=\"LFS-LP\").Rsep)\n\nfor moment in [\"mean\", \"std\", \"skew\", \"kurt\"]:\n    plt.figure()\n\n    mean, error = tcvx21.analysis.compute_statistical_moment_with_bootstrap(\n        values=values, moment=moment, ci=0.95, n_tests=1000\n    )\n    plot_region(Rsep, Q(mean), Q(error), label=\"95%\")\n\n    mean, error = tcvx21.analysis.compute_statistical_moment_with_bootstrap(\n        values=values, moment=moment, ci=0.65, n_tests=1000\n    )\n    plot_region(Rsep, Q(mean), Q(error), label=\"65%\")\n\n    plt.legend(title=\"Confidence interval\")\n    plt.title(f\"$J_{{sat}}$ {moment} on low-field-side target\")\n\nif test_session:\n    plt.close(\"all\")\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nfrom netCDF4 import Dataset\n\nstandard_dict = read_from_json(tcvx21.template_file)\nsimulation_hierarchy = read_from_json(file_path / \"simulation_hierarchy.json\")\nwork_file_path = file_path / \"processing_file.nc\"\n\ndataset = Dataset(work_file_path)\n\n\ndef strip_moment(observable_key):\n    if observable.endswith(\"_std\"):\n        moment = \"std\"\n        key = observable_key.rstrip(\"std\").rstrip(\"_\")\n    elif observable.endswith(\"_skew\"):\n        moment = \"skew\"\n        key = observable_key.rstrip(\"skew\").rstrip(\"_\")\n    elif observable.endswith(\"_kurtosis\"):\n        moment = \"kurt\"\n        key = observable_key.rstrip(\"kurtosis\").rstrip(\"_\")\n    else:\n        moment = \"mean\"\n        key = observable_key\n    return key, moment\n\n\ndef write_observable(diagnostic_key, observable_key, output_dict):\n\n    print(f\"\\tProcessing {diagnostic_key}:{observable_key}\")\n\n    observable_key, moment = strip_moment(observable_key)\n\n    diagnostic = xr.open_dataset(work_file_path, group=diagnostic_key)\n    observable = xr.open_dataset(work_file_path, group=f\"{diagnostic_key}/observables\")[\n        observable_key\n    ]\n    observable = observable.isel(tau=slice(-500, None)).persist()\n\n    output_dict[\"simulation_hierarchy\"] = simulation_hierarchy[\n        observable_key if moment != \"lambda_q\" else moment\n    ]\n\n    value, error = tcvx21.analysis.compute_statistical_moment_with_bootstrap(\n        observable, moment=moment\n    )\n\n    output_dict[\"values\"] = Q(value).to(output_dict[\"units\"]).magnitude\n    output_dict[\"errors\"] = Q(error).to(output_dict[\"units\"]).magnitude\n\n    for variable_key in diagnostic.variables.keys():\n        variable = diagnostic[variable_key]\n        output_key = variable_key.replace(\"Rsep\", \"Ru\")\n\n        output_dict[output_key] = variable.values\n        output_dict[f\"{output_key}_units\"] = getattr(variable, \"units\", \"\")\n\n\nprint(\"Filling standard dict\")\n\nfor diagnostic, diagnostic_dict in standard_dict.items():\n    for observable, observable_dict in diagnostic_dict[\"observables\"].items():\n        write_observable(diagnostic, observable, observable_dict)\n\nprint(\"Done\")\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# Finally, we write this into a standard NetCDF\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nfrom tcvx21.record_c.record_writer_m import RecordWriter\n\nwriter = RecordWriter(\n    file_path=file_path / \"GRILLIX_example.nc\",\n    descriptor=\"GRX\",\n    description=Path(file_path / \"description.txt\").read_text(),\n    allow_overwrite=True,\n)\n\nwriter.write_data_dict(standard_dict)\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# To perform the entire setup and file write in a single step, you can also use\n# the following command, although this is more for convenience\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nfrom tcvx21.grillix_post.validation_writer_m import (\n    convert_work_file_to_validation_netcdf,\n)\n\nconvert_work_file_to_validation_netcdf(\n    work_file=file_path / \"processing_file.nc\",\n    output_file=file_path / \"GRILLIX_example.nc\",\n    simulation_hierarchy=tcvx21.read_from_json(\n        tcvx21.grillix_dir / \"simulation_hierarchy.json\"\n    ),\n)\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# We can then load this as a `Record` -- a NetCDF file which has a rigid common\n# structure shared between the simulations and the experiment.\n#\n# This allows us to write interfaces to the data -- i.e. plotting routines -- and\n# don't have to worry about which data source the data is coming from\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nfrom tcvx21.record_c.record_m import Record\n\nds = Record(file_path / \"GRILLIX_example.nc\", color=\"C1\", label=\"GRILLIX\")\n\nplt.figure()\nds.get_observable(\"LFS-LP\", \"density\").plot()\n\nplt.figure()\nds.get_observable(\"RDPA\", \"density\").plot(log_cbar=True)\n\nif test_session:\n    plt.close(\"all\")\n# %%\n", "meta": {"hexsha": "3a35ab7a14308642e01599d6d47e6ab0795ac2b1", "size": 28322, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks/simulation_postprocessing.py", "max_stars_repo_name": "dsoliveir/TCV-X21", "max_stars_repo_head_hexsha": "784c55adb33417e21a6736e2504a3895a9348dbe", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-12-13T11:52:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-13T11:52:39.000Z", "max_issues_repo_path": "notebooks/simulation_postprocessing.py", "max_issues_repo_name": "dsoliveir/TCV-X21", "max_issues_repo_head_hexsha": "784c55adb33417e21a6736e2504a3895a9348dbe", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-12-18T17:18:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-26T09:23:23.000Z", "max_forks_repo_path": "notebooks/simulation_postprocessing.py", "max_forks_repo_name": "dsoliveir/TCV-X21", "max_forks_repo_head_hexsha": "784c55adb33417e21a6736e2504a3895a9348dbe", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-12-13T12:56:09.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T20:30:28.000Z", "avg_line_length": 36.7818181818, "max_line_length": 212, "alphanum_fraction": 0.7184167785, "include": true, "reason": "import numpy,from scipy", "num_tokens": 7810, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.16238003666671086, "lm_q1q2_score": 0.08119001833335543}}
{"text": "![Callysto.ca Banner](https://github.com/callysto/curriculum-notebooks/blob/master/callysto-notebook-banner-top.jpg?raw=true)\n\n<a href=\"https://hub.callysto.ca/jupyter/hub/user-redirect/git-pull?repo=https%3A%2F%2Fgithub.com%2Fcallysto%2Fcurriculum-notebooks&branch=master&subPath=Mathematics/BudgetAndBankingAssignment/budget-and-banking-assignment.ipynb&depth=1\" target=\"_parent\"><img src=\"https://raw.githubusercontent.com/callysto/curriculum-notebooks/master/open-in-callysto-button.svg?sanitize=true\" width=\"123\" height=\"24\" alt=\"Open in Callysto\"/></a>\n\n%%html\n\n<script>\n  function code_toggle() {\n    if (code_shown){\n      $('div.input').hide('500');\n      $('#toggleButton').val('Show Code')\n    } else {\n      $('div.input').show('500');\n      $('#toggleButton').val('Hide Code')\n    }\n    code_shown = !code_shown\n  }\n\n  $( document ).ready(function(){\n    code_shown=false;\n    $('div.input').hide()\n  });\n</script>\n<p> Code is hidden for ease of viewing. Click the Show/Hide button to see. </>\n<form action=\"javascript:code_toggle()\"><input type=\"submit\" id=\"toggleButton\" value=\"Show Code\"></form>\n\n# Modules\n\nimport string\nimport numpy as np\nimport pandas as pd\nimport qgrid as q\nimport matplotlib.pyplot as plt\n\n# Widgets & Display modules, etc..\n\nfrom ipywidgets import widgets as w\nfrom ipywidgets import Button, Layout\nfrom IPython.display import display, Javascript, Markdown, HTML\n\n# grid features for interactive grids \n\ngrid_features = { 'fullWidthRows': True,\n                  'syncColumnCellResize': True,\n                  'forceFitColumns': True,\n                  'rowHeight': 40,\n                  'enableColumnReorder': True,\n                  'enableTextSelectionOnCells': True,\n                  'editable': True,\n                  'filterable': False,\n                  'sortable': False,\n                  'highlightSelectedRow': True}\n\ndef rerun_cell( b ):\n    \n    display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1,IPython.notebook.get_selected_index()+2)'))    \n\ndef check_answers(series_input,answer_list):\n    \n    # convert valid answer list to string format \n    \n    valid_answers = \"\"\n    \n    for item in answer_list:\n        \n        valid_answers = valid_answers + item + \",\"\n        \n    valid_answers = valid_answers[:len(valid_answers)-1]\n    \n    # compare student's answers to answer list\n        \n    for entry in series_input:\n        \n        if(entry != '' and entry not in answer_list):\n            \n            # display(Markdown(\"Some of your inputs are invalid. Please enter valid inputs from the following: \", valid_answers))\n            \n            return 0\n        \n    return 1\n\nname_text = w.Textarea( value='', placeholder='STUDENT NAME', description='', disabled=False , layout=Layout(width='30%', height='32.5px') )\ndate_text = w.Textarea( value='', placeholder='DATE', description='', disabled=False , layout=Layout(width='30%', height='32.5px') )\nprofile_button = w.Button(button_style='info',description=\"Save\", layout=Layout(width='15%', height='30px'))\n\ndisplay(name_text)\ndisplay(date_text)\ndisplay(profile_button)\n\nprofile_button.on_click( rerun_cell ) \n\nname = name_text.value\ndate = date_text.value\n\nname_saved = False\ndate_saved = False\n\nif(name != ''):\n    \n    name_text.close()\n    display(Markdown(\"### Student Name: $\\hspace{1.5cm}$\"+ name ))\n    name_saved = True\n    \nif(date != ''):\n    \n    date_text.close()\n    display(Markdown(\"### $\\hspace{2.15cm}$Date: $\\hspace{1.5cm}$\"+ date ))\n    date_saved = True\n    \nif(name_saved == True and date_saved == True):\n    \n    profile_button.close()\n\n# Budget and Banking\n\n## Assignment Lesson 1\n\nanswers_recorded = 0\nq1_answered = 0\nq2_answered = 0\nq3a_answered = 0\nq3b_answered = 0\nq3c_answered = 0\nq3d_answered = 0\n\nFor question 1 and 2, choose the best answer.\n\n**Question 1.** A good reason for preparing a budget\n\nif(q1_answered == 1):\n    \n    q1_answered += 1\n    q1_student_answer = q1_choices.value\n    correct_answer = 'd.) All the above are good reasons for preparing a budget'\n    \n    if(q1_student_answer == correct_answer):\n        \n        display(Markdown(\"### You answered: \"))\n        display(Markdown(q1_student_answer))\n        \n        display(Markdown(\"This is correct!\"))\n        \n    else:\n        \n        display(Markdown(\"### You answered: \"))\n        display(Markdown(q1_student_answer))\n\n        display(Markdown(\"This is incorrect.\"))\n        display(Markdown(\"### Correct answer: \"))\n        display(Markdown(correct_answer))\n        \nelse:\n    \n    # Question 1 Answer Choices\n\n    choice_1 = 'a.) Running out of money each month'\n    choice_2 = 'b.) To reduce debt'\n    choice_3 = 'c.) To save for something special'\n    choice_4 = 'd.) All the above are good reasons for preparing a budget'\n\n    answer_choices = [ choice_1,choice_2,choice_3,choice_4 ]\n\n    # Question 1 choices widget \n\n    q1_choices = w.RadioButtons( options=answer_choices , description=\"\" , disabled=False , layout=Layout(width='100%'))\n    display(q1_choices)\n\nq1_answered += 1\n\ndef record_answer(button_widget):\n    \n    display(Javascript('IPython.notebook.execute_cell_range( IPython.notebook.get_selected_index()-1 , IPython.notebook.get_selected_index()+1) '))    \n    q1_choices.close()\n    \nif(q1_answered >= 2):\n    \n    q1_button.close()\n    \nelse:\n    \n    q1_button = w.Button(button_style='info',description=\"Record Answer\", layout=Layout(width='15%', height='30px'))\n    q1_button.on_click( record_answer ) \n    display(q1_button)\n\n**Question 2.** Which equation best describes gross and net pay?\n\nif(q2_answered == 1):\n    \n    q2_answered += 1\n    q2_student_answer = q2_choices.value\n    correct_answer = 'b.) Net Pay = Gross Pay - Deductions'\n    \n    if(q2_student_answer == correct_answer):\n\n        display(Markdown(\"### You answered: \"))\n        display(Markdown(q2_student_answer))\n        \n        display(Markdown(\"This is correct!\"))\n        \n    else:\n        \n        display(Markdown(\"### You answered: \"))\n        display(Markdown(q2_student_answer))\n\n        display(Markdown(\"This is incorrect.\"))\n        display(Markdown(\"### Correct answer: \"))\n        display(Markdown(correct_answer))\n    \nelse:\n\n    # Question 2 Answer Choices\n\n    choice_1 = 'a.) Gross Pay = Net Pay - Deductions'\n    choice_2 = 'b.) Net Pay = Gross Pay - Deductions'\n    choice_3 = 'c.) Gross Pay = Net Pay ÷ Deductions'\n    choice_4 = 'd.) Net Pay = Gross Pay ÷ Deductions'\n\n    answer_choices = [ choice_1,choice_2,choice_3,choice_4 ]\n\n    q2_choices = w.RadioButtons( options=answer_choices , description=\"\" , disabled=False , layout=Layout(width='100%'))\n    display(q2_choices)\n\nq2_answered += 1\n\ndef record_answer(button_widget):\n    \n    display(Javascript('IPython.notebook.execute_cell_range( IPython.notebook.get_selected_index()-1 , IPython.notebook.get_selected_index()+1) '))    \n    q2_choices.close()\n    \nif(q2_answered >= 2):\n    \n    q2_button.close()\n    \nelse:\n    \n    q2_button = w.Button(button_style='info',description=\"Record Answer\", layout=Layout(width='15%', height='30px'))\n    q2_button.on_click( record_answer ) \n    display(q2_button)\n\n**Question 3.** Label the following incomes as **fixed** or **variable**. Explain reasons for each.\n\n$\\hspace{0.35cm}$**a.)** Lloyd earns $50.00 for every set of knife he sells.\n\nif(q3a_answered == 1):\n    \n    q3a_answered += 1\n    q3a_student_answer = q3a_choices.value\n    correct_answer = 'Variable'\n\n    if(q3a_student_answer == correct_answer):\n        \n        display(Markdown(\"### You answered: \"))\n        display(Markdown(q3a_student_answer))\n        \n        display(Markdown(\"This is correct!\"))\n        \n    else:\n        \n        display(Markdown(\"### You answered: \"))\n        display(Markdown(q3a_student_answer))\n\n        display(Markdown(\"This is incorrect.\"))\n        display(Markdown(\"### Correct answer: \"))\n        display(Markdown(correct_answer))\n    \nelse:\n\n    # Question 3.a Answer Choices\n\n    choice_1 = 'Fixed'\n    choice_2 = 'Variable'\n\n    answer_choices = [ choice_1,choice_2 ]\n\n    q3a_choices = w.RadioButtons( options=answer_choices , description=\"\" , disabled=False , layout=Layout(width='100%'))\n    display(q3a_choices)\n\nq3a_answered += 1\n\ndef record_answer(button_widget):\n    \n    display(Javascript('IPython.notebook.execute_cell_range( IPython.notebook.get_selected_index()-1 , IPython.notebook.get_selected_index()+1) '))    \n    q3a_choices.close()\n    \nif(q3a_answered >= 2):\n    \n    q3a_button.close()\n    \nelse:\n    \n    q3a_button = w.Button(button_style='info',description=\"Record Answer\", layout=Layout(width='15%', height='30px'))\n    q3a_button.on_click( record_answer ) \n    display(q3a_button)\n\n$\\hspace{0.35cm}$**b.)** Each month, Florence is paid 4.5% commission on her first $1,500.00 in sales. If she makes more than this, Florence is paid 6% in commission.\n\nif(q3b_answered == 1):\n    \n    q3b_answered += 1\n    q3b_student_answer = q3b_choices.value\n    correct_answer = 'Variable'\n    \n    if(q3b_student_answer == correct_answer):\n        \n        display(Markdown(\"### You answered: \"))\n        display(Markdown(q3b_student_answer))\n        \n        display(Markdown(\"This is correct!\"))\n        \n    else:\n        \n        display(Markdown(\"### You answered: \"))\n        display(Markdown(q3b_student_answer))\n\n        display(Markdown(\"This is incorrect.\"))\n        display(Markdown(\"### Correct answer: \"))\n        display(Markdown(correct_answer))\n    \nelse:\n\n    # Question 3.b Answer Choices\n\n    choice_1 = 'Fixed'\n    choice_2 = 'Variable'\n\n    answer_choices = [ choice_1,choice_2 ]\n\n    q3b_choices = w.RadioButtons( options=answer_choices , description=\"\" , disabled=False , layout=Layout(width='100%'))\n    display(q3b_choices)\n\nq3b_answered += 1\n\ndef record_answer(button_widget):\n    \n    display(Javascript('IPython.notebook.execute_cell_range( IPython.notebook.get_selected_index()-1 , IPython.notebook.get_selected_index()+1) '))    \n    q3b_choices.close()\n    \nif(q3b_answered >= 2):\n    \n    q3b_button.close()\n    \nelse:\n    \n    q3b_button = w.Button(button_style='info',description=\"Record Answer\", layout=Layout(width='15%', height='30px'))\n    q3b_button.on_click( record_answer ) \n    display(q3b_button)\n\n$\\hspace{0.35cm}$**c.)** Corinne works 40 hours a week at $17.00 an hour. She is paid bi-weekly (every two weeks).\n\nif(q3c_answered == 1):\n    \n    q3c_answered += 1\n    q3c_student_answer = q3c_choices.value\n    correct_answer = 'Fixed'\n    \n    if(q3c_student_answer == correct_answer):\n        \n        display(Markdown(\"### You answered: \"))\n        display(Markdown(q3c_student_answer))\n        \n        display(Markdown(\"This is correct!\"))\n        \n    else:\n        \n        display(Markdown(\"### You answered: \"))\n        display(Markdown(q3c_student_answer))\n\n        display(Markdown(\"This is incorrect.\"))\n        display(Markdown(\"### Correct answer: \"))\n        display(Markdown(correct_answer))\n    \nelse:\n\n    # Question 3.c Answer Choices\n\n    choice_1 = 'Fixed'\n    choice_2 = 'Variable'\n\n    answer_choices = [ choice_1,choice_2 ]\n\n    q3c_choices = w.RadioButtons( options=answer_choices , description=\"\" , disabled=False , layout=Layout(width='100%'))\n    display(q3c_choices)\n\nq3c_answered += 1\n\ndef record_answer(button_widget):\n    \n    display(Javascript('IPython.notebook.execute_cell_range( IPython.notebook.get_selected_index()-1 , IPython.notebook.get_selected_index()+1) '))    \n    q3c_choices.close()\n    \nif(q3c_answered >= 2):\n    \n    q3c_button.close()\n    \nelse:\n    \n    q3c_button = w.Button(button_style='info',description=\"Record Answer\", layout=Layout(width='15%', height='30px'))\n    q3c_button.on_click( record_answer ) \n    display(q3c_button)\n\n$\\hspace{0.35cm}$**d.)** Gord earns a salary of $3,000.00 each month.\n\nif(q3d_answered == 1):\n    \n    q3d_answered += 1\n    q3d_student_answer = q3d_choices.value\n    correct_answer = 'Fixed'\n    \n    if(q3d_student_answer == correct_answer):\n        \n        display(Markdown(\"### You answered: \"))\n        display(Markdown(q3d_student_answer))\n        \n        display(Markdown(\"This is correct!\"))\n        \n    else:\n        \n        display(Markdown(\"### You answered: \"))\n        display(Markdown(q3d_student_answer))\n\n        display(Markdown(\"This is incorrect.\"))\n        display(Markdown(\"### Correct answer: \"))\n        display(Markdown(correct_answer))\n    \nelse:\n\n    # Question 3.d Answer Choices\n\n    choice_1 = 'Fixed'\n    choice_2 = 'Variable'\n\n    answer_choices = [ choice_1,choice_2 ]\n\n    q3d_choices = w.RadioButtons( options=answer_choices , description=\"\" , disabled=False , layout=Layout(width='100%'))\n    display(q3d_choices)\n\nq3d_answered += 1\n\ndef record_answer(button_widget):\n    \n    display(Javascript('IPython.notebook.execute_cell_range( IPython.notebook.get_selected_index()-1 , IPython.notebook.get_selected_index()+1) '))    \n    q3d_choices.close()\n    \nif(q3d_answered >= 2):\n    \n    q3d_button.close()\n    \nelse:\n    \n    q3d_button = w.Button(button_style='info',description=\"Record Answer\", layout=Layout(width='15%', height='30px'))\n    q3d_button.on_click( record_answer ) \n    display(q3d_button)\n\n4) Lian works in a retail store $35$ hours a week. She is paid $\\$12.75$ an hour bi-weekly (every two weeks). Her last paycheque had a deduction of $\\$71.19$ for Income Tax, $\\$35.82$ for CPP, and $\\$14.85$ for EI.\n\n$\\hspace{1.5cm}$a.) Determine Lian's gross pay for two weeks.\n\n**Write your calculations below.** \n* Valid inputs: Numbers and decimals. \n* Valid operations: `+,-,*` for addition, subtraction, and multiplication, respectively.\n\n**Example input:** `40 * 10 * 2 + 30`\n\nq4a_text = w.Textarea( value='', placeholder='Your calculations for Exercise 4.a.', description='', disabled=False , layout=Layout(width='100%', height='30px') )\nq4a_button = w.Button(button_style='info',description=\"Calculate\", layout=Layout(width='15%', height='30px'))\n\ndisplay(q4a_text)\ndisplay(q4a_button)\n\nq4a_button.on_click( rerun_cell ) \n\n# Obtain user's input\n\nq4a_input = q4a_text.value\n\n# Define the valid character inputs for this exercise\n\nnumbers = '0123456789'\noperations = '+-*'\nothers = ' .'\nvalid_inputs = numbers + operations + others\n\n# Check if every character in user's string input is valid\n\nuser_input_valid = all( ch in valid_inputs for ch in q4a_input)\n\n# Check for correctness of user's calculation\n\nif(q4a_input != '' and user_input_valid == True):\n    \n    user_answer = eval(q4a_input)\n    \n    display(Markdown(\"### You answered: \"))\n    display(Markdown(\"$\\$\"+str(round(user_answer,2))+\"$\"))\n    \n    if(user_answer == 892.50):\n    \n        display(Markdown(\"Your calculation is correct!\"))\n\n        q4a_button.close()\n        q4a_text.close()\n        \n    else:\n        \n        display(Markdown(\"Your calculation is incorrect. Try again.\"))\n  \nif(q4a_input != '' and user_input_valid == False):\n    \n    display(Markdown(\"Your answer contains invalid inputs or operations.\"))\n\n$\\hspace{1.5cm}$b.) Determine Lian's net pay for two weeks. \n\nq4b_text = w.Textarea( value='', placeholder='Your calculations for Exercise 4.b.', description='', disabled=False , layout=Layout(width='100%', height='30px') )\nq4b_button = w.Button(button_style='info',description=\"Calculate\", layout=Layout(width='15%', height='30px'))\n\ndisplay(q4b_text)\ndisplay(q4b_button)\n\nq4b_button.on_click( rerun_cell ) \n\n# Obtain user's input\n\nq4b_input = q4b_text.value\n\n# Define the valid character inputs for this exercise\n\nnumbers = '0123456789'\noperations = '+-*'\nothers = ' .'\nvalid_inputs = numbers + operations + others\n\n# Check if every character in user's string input is valid\n\nuser_input_valid = all( ch in valid_inputs for ch in q4a_input)\n\n# Check for correctness of user's calculation\n\nif(q4b_input != '' and user_input_valid == True):\n    \n    user_answer = round(eval(q4b_input),2)\n    correct_answer = round(eval(\"892.5 - 71.19 - 35.82 - 14.85\"),2)\n    \n    display(Markdown(\"### You answered: \"))\n    display(Markdown(\"$\\$\"+str(round(user_answer,2))+\"$\"))\n    \n    if(user_answer == correct_answer):\n\n        q4b_button.close()\n        q4b_text.close()\n        \n        display(Markdown(\"Your calculation is correct!\"))\n        \n    else:\n        \n        display(Markdown(\"Your calculation is incorrect. Try again.\"))    \n\nif(q4b_input != '' and user_input_valid == False):\n    \n    display(Markdown(\"Your answer contains invalid inputs or operations.\"))\n\n---\n\n<h1 align='center'>Character Section Lesson</h1>\n\nTo conclude the Chapter 1 Assignment, you will be constructing a conservative budget and answering a \"what if\" question. You will be marked using a rubric that is located on the last page of the booklet.\n\n### Character Background\n\nEmma, a high school student working at a local grocery store as a cashier.\n\n### Personal Background\n\nEmma is 16 years old, in grade 11 and living at home with her parents. She plays soccer and rugby. Emma is the bass player in a band. Currently, she is using an old bass guitar that her dad played in the 1980s, and she would like to buy her own. Her goal is to buy it in five months because the band has a big gig coming up in six months. The new bass costs $828.45 including GST.\n\n\n### Salary\n\n\nEmma works part-time at Gobey’s Grocery. She is paid a biweekly amount of $321.13.\n\nEmma babysits occasionally for her neighbours for $10.00 an hour. Several of Emma's babysitting client pay her by cheque, and Emma puts the money directly into her bank account.\n\n### Expenses\n\nEmma’s parents have encouraged her to save for post-secondary schooling. To achieve this, Emma and her parents set up a direct withdrawal from her bank account of $40.00 a paycheque into an RESP account. Emma pays for her own transit pass, which she uses to travel around the city. Emma is very thrifty and creative, so she chooses to shop for clothing at local second-hand stores. Emma’s position as the bass player in a local band requires her to maintain her instrument and provide her own sound equipment.\n\nEmma downloads the bank record of her spending during two months (February and March).\n\n### Notes\n\n* The credit column contains all income (part-time job and babysitting).\n\n* The debit column contains all expenses that Emma has paid.\n\n* An automatic withdrawal of $40.00 each paycheque goes into an RESP account.\n\n* In February, Emma paid rugby fees with cash, which are $180.00.\n\n* At the end of March, Emmas’ soccer team went to an overnight tournament for which she paid $160.00 in cash as her portion of the hotel room.\n\n<h2 align='center'>Character Section Lesson Exercises</h2>\n\n**Question 1.** List **at least two** reasons Emma might want to prepare a budget for herself.\n\nemma1_text = w.Textarea( value='', placeholder='Write your answer here for Question 1.', description='', disabled=False , layout=Layout(width='100%', height='75px') )\nemma1_button = w.Button(button_style='info',description=\"Record Answer\", layout=Layout(width='15%', height='30px'))\n\ndisplay(emma1_text)\ndisplay(emma1_button)\n\nemma1_button.on_click( rerun_cell ) \n\nemma1_input = emma1_text.value\n\nif(emma1_input != ''):\n    \n    emma1_text.close()\n    emma1_button.close()\n    display(Markdown(\"### Your answer for Question 1:\"))\n    display(Markdown(emma1_input))\n\n**Question 2.** Determine Emma’s net income for the month of February and March. Her bank statements are displayed below.\n\n# Prepare dataframes for Emma's February & March Transactions\n\nentry_types = {'Debit ($)': str , 'Credit ($)' : str}\n\nfebruary_transactions_df = pd.read_csv('./data/februarytransactions.csv',converters=entry_types)\nfebruary_transactions_df.set_index('Date',inplace=True)\nfebruary_transactions_df[['Debit ($)','Credit ($)']] = february_transactions_df[['Debit ($)','Credit ($)']].replace(np.nan,\"0.00\")\n\nmarch_transactions_df = pd.read_csv('./data/marchtransactions.csv',converters=entry_types)\nmarch_transactions_df.set_index('Date',inplace=True)\nmarch_transactions_df[['Debit ($)','Credit ($)']] = march_transactions_df[['Debit ($)','Credit ($)']].replace(np.nan,\"0.00\")\n\n# Control grid features\n\nemma_grid_features = { 'fullWidthRows': True,\n                  'syncColumnCellResize': True,\n                  'forceFitColumns': True,\n                  'rowHeight': 40,\n                  'enableColumnReorder': True,\n                  'enableTextSelectionOnCells': True,\n                  'editable': False,\n                  'filterable': False,\n                  'sortable': False,\n                  'highlightSelectedRow': True}\n\nq_emma_feb = q.show_grid( february_transactions_df , grid_options = emma_grid_features ) \nq_emma_mar = q.show_grid( march_transactions_df , grid_options = emma_grid_features ) \n\ndisplay(Markdown(\"<h2 align='center'>Emma's February Transactions</h2>\"))\n\ndisplay(q_emma_feb)\n\n**Write your calculations below.**\n* Valid inputs: Numbers and decimals.\n* Valid operations: `+` for addition.\n\n**Example input:** `35 + 27.13 + 11.32`\n\nfeb_text = w.Textarea( value='', placeholder=\"Enter your calculation here to determine Emma's net income for the month of February. Hint: which column do Emma's income come from?\", description='', disabled=False , layout=Layout(width='100%', height='30px') )\nfeb_button = w.Button(button_style='info',description=\"Calculate\", layout=Layout(width='15%', height='30px'))\n\ndisplay(feb_text)\ndisplay(feb_button)\n\nfeb_button.on_click( rerun_cell ) \n\n# Obtain user's input\n\nfeb_input = feb_text.value\n\n# Define the valid character inputs for this exercise\n\nnumbers = '0123456789'\noperations = '+'\nothers = ' .'\nvalid_inputs = numbers + operations + others\n\n# Check if every character in user's string input is valid\n\nuser_input_valid = all( ch in valid_inputs for ch in feb_input)\n\n# Check for correctness of user's calculation\n\nif(feb_input != '' and user_input_valid == True):\n    \n    user_answer = eval(feb_input)\n    \n    display(Markdown(\"### You answered: \"))\n    display(Markdown(\"$\\$\"+str(user_answer)+\"$\"))\n    \n    if(user_answer == 1042.26):\n                \n        feb_button.close()\n        feb_text.close()\n        \n        display(Markdown(\"Your calculation is correct!\"))\n        \n    else:\n        \n        display(Markdown(\"Your calculation is incorrect. Try again.\"))   \n\nif(feb_input != '' and user_input_valid == False):\n    \n    display(Markdown(\"Your answer contains invalid inputs or operations.\"))\n\ndisplay(Markdown(\"<h2 align='center'>Emma's March Transactions</h2>\"))\n\ndisplay(q_emma_mar)\n\n**Write your calculations below.**\n* Valid inputs: Numbers and decimals.\n* Valid operations: `+` for addition.\n\n**Example input:** `35 + 27.13 + 11.32`\n\nmar_text = w.Textarea( value='', placeholder=\"Enter your calculation here to determine Emma's net income for the month of March. Hint: which column do Emma's income come from?\", description='', disabled=False , layout=Layout(width='100%', height='30px') )\nmar_button = w.Button(button_style='info',description=\"Calculate\", layout=Layout(width='15%', height='30px'))\n\ndisplay(mar_text)\ndisplay(mar_button)\n\nmar_button.on_click( rerun_cell ) \n\n# Obtain user's input\n\nmar_input = mar_text.value\n\n# Define the valid character inputs for this exercise\n\nnumbers = '0123456789'\noperations = '+'\nothers = ' .'\nvalid_inputs = numbers + operations + others\n\n# Check if every character in user's string input is valid\n\nuser_input_valid = all( ch in valid_inputs for ch in mar_input)\n\n# Check for correctness of user's calculation\n\nif(mar_input != '' and user_input_valid == True):\n    \n    user_answer = eval(mar_input)\n    \n    display(Markdown(\"### You answered: \"))\n    display(Markdown(\"$\\$\"+str(user_answer)+\"$\"))\n    \n    if(user_answer == 922.26):\n        \n        mar_button.close()\n        mar_text.close()\n        \n        display(Markdown(\"Your calculation is correct!\"))\n        \n    else:\n        \n        display(Markdown(\"Your calculation is incorrect. Try again.\"))     \n\nif(mar_input != '' and user_input_valid == False):\n    \n    display(Markdown(\"Your answer contains invalid inputs or operations.\"))\n\n**Question 3.** Categorize Emma’s income as fixed, variable or both. Explain.\n\nemma3_text = w.Textarea( value='', placeholder='Write your answer here for Question 3.', description='', disabled=False , layout=Layout(width='100%', height='75px') )\nemma3_button = w.Button(button_style='info',description=\"Record Answer\", layout=Layout(width='15%', height='30px'))\n\ndisplay(emma3_text)\ndisplay(emma3_button)\n\nemma3_button.on_click( rerun_cell ) \n\nemma3_input = emma3_text.value\n\nif(emma3_input != ''):\n    \n    emma3_text.close()\n    emma3_button.close()\n    display(Markdown(\"### Your answer for Question 3:\"))\n    display(Markdown(emma3_input))\n\n<h2 align='center'>Interactive Exercise: Entering & Saving Spreadsheet Data</h2>\n\n**Question 4.** By analyzing the bank statements for the two months, complete the following tables for each month.\n\n$\\hspace{0.35cm}$**a.)** For each row in the table, fill the **Expense Category** column with the appropriate expense label. The valid choices are listed below - write the associated upper case letter for each expense. Expand the **Description** column to see the expense entry.\n\n**Categories: **\n\n$$\\text{(S) Savings, (U) Utilities, (C) Clothing, (E) Entertainment, (M) Miscellaneous, (P) Personal Care, (T) Transportation, (F) Food}$$\n\n# Note to developers:\n# 1. data in tables below obtained by converting relevant pages from Math20-3Unit1Key.pdf into .csv format.\n# 2. this part of the interactive focuses on categorizing expenses\n\n# Answer key for this lesson\n\nfeb_expenses_answer_key = ['S', 'T', 'F', 'U', 'F', 'F', 'F', 'C', 'E', 'S', 'F', 'F', 'E', 'M', 'M', 'F', 'F', 'M', 'M', 'C']\nfeb_fv_answer_key = ['V','V','V','V','F','F','F']\n\n# Setting up the dataframe \n\npd.options.display.max_rows = 50 \n\nentry_types = {'Debit ($)': str , 'Balance ($)' : str}\n\nfebruary_df = pd.read_csv('./data/februarydebits.csv',converters=entry_types)\nfebruary_df.set_index('Transaction #',inplace=True)\nfebruary_df['Debit ($)'] = february_df['Debit ($)'].replace(np.nan,\"0.00\")\nfebruary_df['Expense Category'] = february_df['Expense Category'].replace(np.nan,\"\")\n\noriginal_feb_df = february_df[['Date','Description','Debit ($)','Balance ($)']]\n\n# Display interactive grid 1: categorizing expenses\n\nq_february_df = q.show_grid( february_df , grid_options = grid_features )\n\n# Recording answers\n\nq4a_button = w.Button(button_style='info',description=\"Record Answers\", layout=Layout(width='15%', height='30px'))\n\ndef record_spreadsheet(button_widget):\n    \n    display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1,IPython.notebook.get_selected_index()+3)'))\n\ndisplay(q_february_df)\ndisplay(q4a_button)\n\nq4a_button.on_click( record_spreadsheet )\n\n# Recover entries\n\nq4a_recover_button = w.Button(button_style='info',description=\"Reset all values\", layout=Layout(width='15%', height='30px'))\n\ndef recover_entries(button_widget):\n    \n    display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()-1,IPython.notebook.get_selected_index()+0)'))\n    \ndisplay(q4a_recover_button)\n\nq4a_recover_button.on_click( recover_entries )\n\n# Obtain the changed dataframe\n\nstudent_feb_df = q_february_df.get_changed_df()\n\n# Check answers\n\nanswer_list = ['S','F','C','E','T','U','M']\n\nanswers_valid = check_answers(student_feb_df['Expense Category'],answer_list)\n\nif(answers_valid == 0):\n    \n    display(Markdown(\"Some of your inputs are invalid. Please enter inputs from the following list: S,U,C,E,M,P,T,F\"))\n\n\n# Group the dataframe according to student's expense categories once student's answers are correct\n\nif(answers_valid == 1):\n    \n    # Check if every entry matches the answer key\n    \n    student_answers = (student_feb_df['Expense Category'].values).tolist() \n    \n    if( feb_expenses_answer_key == student_answers):\n        \n        display(Markdown(\"Your selections are correct!\"))\n\n        q4a_button.close()\n        q4a_recover_button.close()\n        q_february_df.close()\n        \n        q4a_grid_features = { 'fullWidthRows': True,\n                          'syncColumnCellResize': True,\n                          'forceFitColumns': True,\n                          'rowHeight': 40,\n                          'enableColumnReorder': True,\n                          'enableTextSelectionOnCells': True,\n                          'editable': False,\n                          'filterable': False,\n                          'sortable': False,\n                          'highlightSelectedRow': True}\n        \n        student_q4a_df = q.show_grid( student_feb_df , grid_options = q4a_grid_features )\n        \n        display(student_q4a_df)\n        \n    else:\n        \n        display(Markdown(\"Some of your inputs are incorrect.\"))\n\n$\\hspace{0.35cm}$**b.)** Calculate the total of each expense category you used in (a). \n\n$\\hspace{3cm}$This is done for you. Proceed to exercise (c).\n\nq4b_df = pd.read_csv('./data/expensesum.csv')\nq4b_df.set_index(\"Expense Category\",inplace=True)\nq_q4b_df = q.show_grid( q4b_df , grid_options = grid_features ) \ndisplay(q_q4b_df)\n\n$\\hspace{0.35cm}$**c.)** For each category, determine whether it is **fixed** or **variable**. Enter F for fixed and V for variable.\n\n# Setting up the dataframe \n\nfixed_or_var_df = pd.read_csv('./data/fixedorvar.csv')\nfixed_or_var_df.set_index('Expense Category',inplace=True)\nfixed_or_var_df['Fixed or Variable'] = fixed_or_var_df['Fixed or Variable'].replace(np.nan,\"\")\n\nq_fixed_or_var_df = q.show_grid( fixed_or_var_df , grid_options = grid_features)\n\nq4c_button = w.Button(button_style='info',description=\"Record Answers\", layout=Layout(width='15%', height='30px'))\n\ndef record_spreadsheet(button_widget):\n    \n    display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1,IPython.notebook.get_selected_index()+2)'))\n\ndisplay(q_fixed_or_var_df)\ndisplay(q4c_button)\n\nq4c_button.on_click( record_spreadsheet )\n\n# Obtain the changed dataframe\n\nq4c_df = q_fixed_or_var_df.get_changed_df()\n\n# Check answers\n\nq4c_answer_list = ['V','F','V','F','V','V','V','V']\nq4c_student_answer = (q4c_df['Fixed or Variable'].values).tolist()\n\ndef check_q4c(student_inputs):\n    \n    valid_inputs = 'VF'\n    \n    for entry in student_inputs:\n        \n        if(entry not in valid_inputs):\n            \n            display(Markdown(\"Please enter valid inputs only.\"))\n            \n            return False\n        \n        if(entry == ''):\n            \n            display(Markdown(\"Please fill all the entries in the spreadsheet above.\"))\n            \n            return False\n        \n    return True\n        \nif(check_q4c(q4c_student_answer) == True):\n    \n    if(q4c_student_answer == q4c_answer_list):\n        \n        display(Markdown(\"Your selections are correct!\"))\n        \n        q4c_grid_features = { 'fullWidthRows': True,\n                          'syncColumnCellResize': True,\n                          'forceFitColumns': True,\n                          'rowHeight': 40,\n                          'enableColumnReorder': True,\n                          'enableTextSelectionOnCells': True,\n                          'editable': False,\n                          'filterable': False,\n                          'sortable': False,\n                          'highlightSelectedRow': True}\n        \n        student_q4c_df = q.show_grid( q4c_df , grid_options = q4c_grid_features )\n        \n        q_fixed_or_var_df.close()\n        \n        display(student_q4c_df)\n        \n    else:\n        \n        display(Markdown(\"Some inputs are incorrect.\"))\n\n**Question 5.** Construct a **monthly** conservative budget skeleton for Emma based upon her February and March data. To do this, compare the data for February and March and use the _highest_ expense amount for each category.\n\n**Note: ** The **February Expense Data** and **March Expense Data** are given below.\n\nentry_types = {'February Totals ($)': str , 'March Totals ($)' : str}\n\ncomparison_df = pd.read_csv('./data/expensecomparison.csv',converters = entry_types)\ncomparison_df.set_index('Expense Categories',inplace=True)\ncomparison_df['Highest Expense Amount ($)'] = comparison_df['Highest Expense Amount ($)'].replace(np.nan,\"\")\n\ndel comparison_df['Transaction #']\n\nq_comparison_df = q.show_grid( comparison_df , grid_options = grid_features )\n\nexpense_button = w.Button(button_style='info',description=\"Record Answers\", layout=Layout(width='15%', height='30px'))\n\ndef record_spreadsheet(button_widget):\n    \n    display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1,IPython.notebook.get_selected_index()+3)'))    \n    \ndisplay(q_comparison_df)\ndisplay(expense_button)\n\nexpense_button.on_click( record_spreadsheet )\n\n# Recover entries\n\nrecover_button = w.Button(button_style='info',description=\"Reset all values\", layout=Layout(width='15%', height='30px'))\n\ndef recover_entries(button_widget):\n    \n    display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()-1,IPython.notebook.get_selected_index()+0)'))\n    \ndisplay(recover_button)\n\nrecover_button.on_click( recover_entries )\n\n# Obtain changed dataframe\n\nstudent_comparison_df = q_comparison_df.get_changed_df()\n\n# Answers \n\ncorrect_answers = ['80.00', '73.50', '91.95', '30.15', '189.45', '233.64', '206.00', '116.53']\nstudent_answers = (student_comparison_df['Highest Expense Amount ($)'].values).tolist()\n\n# Function to check if every entry is a valid input\n\ndef check_floats(input_array):\n    \n    valid_inputs = '0123456789.'\n    \n    for answer in input_array:\n        \n        current_user_input = all( ch in valid_inputs for ch in answer)\n        \n        if(current_user_input == False):\n        \n            return False\n    \n    return True\n\n# Check if answer is correct\n\nif(check_floats(student_answers) == False):\n    \n    display(Markdown(\"Please enter decimal numbers only.\"))\n        \nelse:\n\n    if(student_answers == correct_answers):\n\n        display(Markdown(\"Your choices are correct!\"))\n\n        recover_button.close()\n        expense_button.close()\n        q_comparison_df.close()\n      \n        comparison_grid_features = { 'fullWidthRows': True,\n                                  'syncColumnCellResize': True,\n                                  'forceFitColumns': True,\n                                  'rowHeight': 40,\n                                  'enableColumnReorder': True,\n                                  'enableTextSelectionOnCells': True,\n                                  'editable': False,\n                                  'filterable': False,\n                                  'sortable': False,\n                                  'highlightSelectedRow': True}\n        \n        student_comparison_df = q.show_grid( student_comparison_df , grid_options = comparison_grid_features )\n        display(student_comparison_df)\n        \n    else:\n        \n        display(Markdown(\"Some of your entries are incorrect. Please fill them with the correct values. Make sure to write numbers in decimal form. Write 80.00 for 80, 206.00, etc.\"))\n\n**Question 6.** If there is excess money, where should Emma put it? If there is not enough income for expenses, suggest how Emma can cover her expenses or reduce her expenses.\n\nq6_text = w.Textarea( value='', placeholder='Write your answer here for Question 6.', description='', disabled=False , layout=Layout(width='100%', height='75px') )\nq6_button = w.Button(button_style='info',description=\"Record Answer\", layout=Layout(width='15%', height='30px'))\n\ndisplay(q6_text)\ndisplay(q6_button)\n\nq6_button.on_click( rerun_cell ) \n\nq6_input = q6_text.value\n\nif(q6_input != ''):\n    \n    q6_text.close()\n    q6_button.close()\n    display(Markdown(\"### Your answer for question 6:\"))\n    display(Markdown(q6_input))\n\n**Question 7.**\n\n$\\hspace{0.35cm}$**a.)** How much will Emma need to save each month to purchase a new base, in 5 months, that costs $\\$828.45$ (including GST)?\n\nq7a_text = w.Textarea( value='', placeholder='Write your answer here for Question 7.a.', description='', disabled=False , layout=Layout(width='100%', height='75px') )\nq7a_button = w.Button(button_style='info',description=\"Record Answer\", layout=Layout(width='15%', height='30px'))\n\ndisplay(q7a_text)\ndisplay(q7a_button)\n\nq7a_button.on_click( rerun_cell ) \n\nq7a_input = q7a_text.value\n\nif(q7a_input != ''):\n    \n    q7a_text.close()\n    q7a_button.close()\n    display(Markdown(\"### Your answer for question 7.a:\"))\n    display(Markdown(q7a_input))\n\n$\\hspace{0.35cm}$**b.)** Based upon her budget, will Emma be able to save enough? If not, modify her budget so that she can afford it. A new category has been added to show her savings for the bass.\n\n**Note:** Income and expenses should be balanced at this point.\n\nFrom the previous exercises, we saw that a conservative income for Emma was $\\$922.26$. In this exercise, we want to create a budget amount in such a way that the sum of each category is exactly $\\$922.26$.\n\n# Prepare dataframes for Emma's February & March Transactions\n\nex_7b_df = pd.read_csv('./data/exercise7b.csv')\nex_7b_df[['Budgeted Amount ($)']] = ex_7b_df[['Budgeted Amount ($)']].replace(np.nan,\"\")\nex_7b_df.set_index('Category',inplace=True)\n\nq_ex_7b = q.show_grid( ex_7b_df , grid_options = grid_features ) \n\ndisplay(Markdown(\"<h2 align='center'>Emma's Modified Conservative Budget</h2>\"))\n\ndisplay(q_ex_7b)\n\nex_7b_button = w.Button(button_style='info',description=\"Record Answers\", layout=Layout(width='15%', height='30px'))\n\ndef record_spreadsheet(button_widget):\n    \n    display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1,IPython.notebook.get_selected_index()+3)'))    \n    \ndisplay(ex_7b_button)\n\nex_7b_button.on_click( record_spreadsheet )\n\n**Question 8.** Determine the percent of Emma’s income on each category. \n\nTo calculate percentage of income for each category use the formula:\n\n$$\\text{Percent of Income} = \\frac{\\text{Amount Allotted for Expense}}{\\text{Budgeted Income}}\\times 100\\%$$\n\n**Note:** This part of the exercise is done for you and changes based on your inputs in exercise 7.b., the formula above is for your reference.\n\n# Set up student inputs as a list\n\nex_7b_student_df = q_ex_7b.get_changed_df()\nstudent_budget_input = ex_7b_student_df['Budgeted Amount ($)']\nstudent_budget_col = (student_budget_input.values).tolist()\n\n# Check if every entry is valid \n\ndef check_ex_7b(student_inputs):\n\n    valid_inputs = '0123456789. '\n\n    for entry in student_inputs:\n\n        for ch in entry:\n            \n            if(ch not in valid_inputs):\n                \n                display(Markdown(\"Please enter valid inputs only.\"))\n\n                return False\n\n    if(entry == ''):\n\n        display(Markdown(\"Please fill all the entries in the spreadsheet above.\"))\n\n        return False\n\n    return True\n\n# Check if student's budget matches the total income\n\nvalid_input = check_ex_7b(student_budget_col)\n\nif(valid_input == True):\n    \n    # Convert every entry to float and get the sum\n    \n    budget_sum = 0\n    \n    for entry in student_budget_col:\n        \n        current_entry = eval(entry)\n        budget_sum += current_entry\n        \n    # If the budget sum matches, then create the percentages chart \n    \n    percentages_col = []\n    \n    if(budget_sum != 922.26): \n        \n        display(Markdown(\"Your budget proposal does not total $922.26. Please try again.\"))\n        \n    else:\n        \n        for entry in student_budget_col:\n            \n            current_percent = round( eval(entry)/budget_sum , 4)\n            percentages_col.append( round(current_percent*100,4) )\n            \n        indices = ['Savings (RESP)','Transportation','Utilities','Food','Clothing','Entertainment','Miscellaneous','Personal Care','Savings (Bass)']\n            \n        percentage_df = pd.DataFrame({'Percentage (%): ': percentages_col },index=indices)\n        updated_ex_7b_student_df = pd.concat( [ex_7b_student_df,percentage_df] , axis = 1 )\n        \n        ex_7b_features = { 'fullWidthRows': True,\n                          'syncColumnCellResize': True,\n                          'forceFitColumns': True,\n                          'rowHeight': 40,\n                          'enableColumnReorder': True,\n                          'enableTextSelectionOnCells': True,\n                          'editable': False,\n                          'filterable': False,\n                          'sortable': False,\n                          'highlightSelectedRow': True}\n        \n        q_ex_7b_updated = q.show_grid( updated_ex_7b_student_df , grid_options = ex_7b_features )\n        \n        display(Markdown(\"<h2 align='center'>Emma's Modified Budget Percentage Breakdown</h2>\"))\n        \n        display(q_ex_7b_updated)\n\n**Question 9.** Are there any categories that Emma is far above or far below the spending guidelines? How does being a high school student affect Emma’s consideration of the spending guidelines?\n\n<img src=\"./images/spending_guidelines.jpg\" alt=\"drawing\" width=\"400px\"/>\n\n\nq9_text = w.Textarea( value='', placeholder='Write your answer here for Question 9', description='', disabled=False , layout=Layout(width='100%', height='75px') )\nq9_button = w.Button(button_style='info',description=\"Record Answer\", layout=Layout(width='15%', height='30px'))\n\ndisplay(q9_text)\ndisplay(q9_button)\n\nq9_button.on_click( rerun_cell ) \n\nq9_input = q9_text.value\n\nif(q9_input != ''):\n    \n    q9_text.close()\n    q9_button.close()\n    display(Markdown(\"### Your answer for question 9:\"))\n    display(Markdown(q9_input))\n\n--- \n<h1 align='center'>Student Interactive Section</h1>\n\nIn this section, you will enter your own expense categories and see how your expense percentage breakdown compares to the spending guideline above.\n\n# Create button and dropdown widget\n\nnumber_of_cat = 13\ndropdown_options = [ str(i+1) for i in range(number_of_cat) ] \ndropdown_widget = w.Dropdown( options = dropdown_options , value = '3' , description = 'Categories' , disabled=False )\n\ncategories_button = w.Button(button_style='info',description=\"Save\", layout=Layout(width='15%', height='30px'))\n\n# Display widgets\n\ndisplay(dropdown_widget)\ndisplay(categories_button)\n\ncategories_button.on_click( rerun_cell ) \n\n# Create dataframe\n\ndf_num_rows = int(dropdown_widget.value)\nempty_list = [ '' for i in range(df_num_rows) ] \ncategory_list = [ i+1 for i in range(df_num_rows) ] \n\n# Set up data input for dataframe\n\ndf_dict = {'Category #': category_list, 'Budget ($)': empty_list , 'Expense Category': empty_list}\n\nstudent_df = pd.DataFrame(data = df_dict)\nstudent_df.set_index('Category #',inplace=True)\n\n# Reorder column labels\n\nstudent_df = student_df[['Expense Category','Budget ($)']]\n\n# Set up & display as Qgrid\n\nq_student_df = q.show_grid( student_df , grid_options = grid_features )\ndisplay(q_student_df)\n\n# Create & display save entries widget button\n\nsave_student_entries_button = w.Button(button_style='info',description=\"Plot Pie Chart\", layout=Layout(width='15%', height='30px'))\ndisplay(save_student_entries_button)\n\nsave_student_entries_button.on_click( rerun_cell ) \n\n# Convert qgrid to dataframe\n\nstudent_updated_df = q_student_df.get_changed_df()\n\nstudent_budget_col = student_updated_df['Budget ($)'].values.tolist()\nstudent_labels_col = student_updated_df['Expense Category'].values.tolist()\n\n# Check if a number if float\n\ndef isfloat(value):\n    \n    try:\n        \n        float(value)\n        \n        return True\n    \n    except ValueError:\n        \n        return False\n\n# Function: Check for validity of budget column entries\n# Input: Student's budget column values\n# Output: Boolean, false if one of the entries is invalid\n\ndef check_budget_column(input_list):\n    \n    valid_inputs = '0123456789.'\n    \n    # Check if inputs are valid\n    \n    for entry in input_list:\n        \n        if( isfloat(entry) == False):\n            \n            return False\n    \n    return True\n\n# Function: Calculate the percentage of each expense category\n# Input: Student expense category lists and student budget column values\n# Output: Percentages column \n\ndef get_percentages(input_list):\n    \n    total = 0\n    percentage_col = []\n    \n    # Obtain total\n    \n    for entry in input_list:\n        \n        entry = eval(entry)        \n        total += entry\n        \n    # Obtain percentages\n    \n    for entry in input_list:\n        \n        entry = eval(entry)\n        current_percentage = entry/total\n        percentage_col.append( round(current_percentage*100,2) )\n    \n    return percentage_col\n\n# If student input is valid, create a pie chart plot\n\ncolors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral','darkseagreen','lightcyan','lightpink','coral','tan','slateblue','azure','tomato','lawngreen']\n\nif(check_budget_column(student_budget_col) == True):\n    \n    student_values = get_percentages(student_budget_col)\n    labels = student_labels_col\n    \n    plt.figure(figsize=(20,10))\n    plt.rcParams['font.size'] = 20\n    plt.title('Your Expense Category Percentage Breakdown',fontsize=25)\n    plt.pie(student_values, labels=labels, colors=colors, autopct='%1.1f%%', shadow=True, startangle=35)\n    plt.axis('equal') \n    plt.show()\n    \nelse:\n    \n    display(Markdown(\"Please enter decimal numbers only for the budget column\"))\n\n[![Callysto.ca License](https://github.com/callysto/curriculum-notebooks/blob/master/callysto-notebook-banner-bottom.jpg?raw=true)](https://github.com/callysto/curriculum-notebooks/blob/master/LICENSE.md)", "meta": {"hexsha": "9a478187cff16456c8193da8a6ed49a4f069c72a", "size": 45500, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/curriculum-notebooks/Mathematics/BudgetAndBankingAssignment/budget-and-banking-assignment.py", "max_stars_repo_name": "BryceHaley/curriculum-jbook", "max_stars_repo_head_hexsha": "d1246799ddfe62b0cf5c389394a18c2904383437", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-18T18:19:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T18:19:40.000Z", "max_issues_repo_path": "_build/jupyter_execute/curriculum-notebooks/Mathematics/BudgetAndBankingAssignment/budget-and-banking-assignment.py", "max_issues_repo_name": "callysto/curriculum-jbook", "max_issues_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/curriculum-notebooks/Mathematics/BudgetAndBankingAssignment/budget-and-banking-assignment.py", "max_forks_repo_name": "callysto/curriculum-jbook", "max_forks_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.6867816092, "max_line_length": 509, "alphanum_fraction": 0.6713626374, "include": true, "reason": "import numpy", "num_tokens": 11017, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48438008427698437, "lm_q2_score": 0.16667540675766923, "lm_q1q2_score": 0.08073424757218048}}
{"text": "#!/usr/bin/env python\nimport numpy as np\nfrom openbabel import pybel\n# import time\nfrom rdkit import Chem\nfrom rdkit.Chem import Draw\nfrom pdbtools.pdbtools import pdbtools\n\n\ndef cal_angle_from_points(dist_lp, dist_dh, dist_ah):\n    cos_theta = (np.power(dist_dh, 2) + np.power(dist_ah, 2) -\n                 np.power(dist_lp, 2)) / (2 * dist_dh * dist_ah)\n    theta = np.arccos(cos_theta)\n\n    return theta\n\n\ndef cal_angle_from_vectors(A, B):\n    cos_theta = np.dot(A, B)\n    theta = np.arccos(cos_theta)\n    return theta\n\n\nclass Pharmacophore(object):\n    \"\"\"\n    pharmacophore\n    \"\"\"\n    feature_type_dict = {\n        'HBD': 0,\n        'HBA': 1,\n        'Anion': 2,\n        'Cation': 3,\n        'Hydrophobic': 4,\n        'Aromatic': 5\n    }\n    feature_type_list = ['HBD', 'HBA', 'Anion',\n                         'Cation', 'Hydrophobic', 'Aromatic']\n\n    complementary_feature = {\n        'HBD': [['HBA', 3.4]],\n        'HBA': [['HBD', 3.4]],\n        'Anion': [['Cation', 5.0]],\n        'Cation': [['Anion', 5.0], ['Aromatic', 5.0]],\n        'Hydrophobic': [['Hydrophobic', 6.5]],\n        'Aromatic': [['Cation', 5.0], ['Aromatic', 6.0]],\n        'MBA': [['Metal', 3.1]],\n        'Metal': [['MBA', 3.1]],\n    }\n\n    num_feature_type = len(feature_type_list)\n    SMARTS_pattern_dict = {\n        'HBD': {\n            0: '[N&H2&v3]',\n            1: '[N&H1&v3]',\n            2: '[N&!H0&+1&v4]',\n            3: '[n&H1&+0]',\n            4: '[n&H1&+1]',\n            5: '[O;H1;+0]',\n            6: '[S;H1;+0]',\n            7: '[O;H2;+0]',\n        },\n        'HBA': {\n            0: '[$([O,S;-])]',\n            1: '[$([O,S;H0;v2])]',\n            2: '[$([O,S;H1;v2]-[!$(*=[O,N,P,S])])]',\n            3: '[$([N;v3;!$(N-*=!@[O,N,P,S])])]',\n            4: '[$([nH0,o,s;+0])]',\n            5: '[$([N;H0]#[C&v4])]',\n            6: '[N&v3;H0;$(Nc)]',\n            7: '[F;$(F-[#6])]',\n            8: '[O;H2;+0]',\n\n        },\n        'Anion': {\n            0: '[-]',\n            1: '[SX4](=O)(=O)(-[O;H1,H0&-1])',\n            2: '[PX4](=O)(-[O;H1,H0&-1])([!O])([!O])',\n            3: '[PX4](=O)(-[O;H1,H0&-1])(-[O;H1,H0&-1])',\n            4: '[CX3,SX3](=[O,S,P])-[O;H1,H0&-1]',\n        },\n        'Cation': {\n            0: '[+]',\n            1: '[NX3]=[CX3]([NX3])[!N]',\n            2: 'NC(=N)N',\n            3: 'c1ncnc1'\n        },\n        'Hydrophobic': {\n            0: '[D3,D4;#6;+0;!$([#6][#7,#8,#9])]',\n            1: '[R0;D2;#6;+0;!$([#6][#7,#8,#9])]',\n            2: '[CX4](F)(F)(F)',\n            3: '[#6;R]',\n            4: '[#17,#35,#53]',\n        },\n        'Aromatic': {\n            0: 'a1:a:a:a:1',\n            1: 'a1:a:a:a:a:1',\n            2: 'a1:a:a:a:a:a:1',\n            3: 'a1:a:a:a:a:a:a:1',\n            4: 'a1:a:a:a:a:a:a:a:1',\n        }\n    }\n\n    metal_name_dict = {\n        'MG': 0,\n        'K': 1,\n        'MN': 2,\n        'FE': 3,\n        'ZN': 4,\n    }\n    metal_type_list = ['MG', 'K', 'MN', 'FE', 'ZN']\n    metal_atomic_name_dict = {12: 'MG', 19: 'K', 25: 'MN', 26: 'FE', 30: 'ZN'}\n    metal_bind_name_dict = {\n        7: 0,\n        8: 1,\n        16: 2,\n    }\n    metal_interaction_cutoff = {\n        0: {2: 2.6, 3: 2.5, 4: 2.56},\n        1: {0: 3.1, 1: 2.4, 2: 2.7, 3: 2.5, 4: 2.8},\n        2: {4: 2.6},\n    }\n\n    weight_pis = {\n        'HBD:HBA': 0.129,\n        'HBA:HBD': 0.129,\n        'Anion:Cation': 0.31,\n        'Cation:Anion': 0.31,\n        'Cation:Aromatic': 0.039,\n        'Hydrophobic:Hydrophobic': 0.00585,\n        'Aromatic:Cation': 0.039,\n        'Aromatic:Aromatic': 0.064,\n        'MBA:Metal': 1.0\n    }\n    bias_pis = 4.0\n    cutoff = 6.5\n    use_pinfo = False\n\n    def __init__(self, params=None):\n        \"\"\"\n            initialize Pharmacophore\n            set parameters\n        \"\"\"\n\n        self.interaction_feature = list(self.weight_pis.keys())\n        if 'weight_pis' in params:\n            self.weight_pis = params['weight_pis']\n        if 'bias_pis' in params:\n            self.bias_pis = params['bias_pis']\n        if 'cutoff' in params:\n            self.cutoff = params['cutoff']\n        cmin = -99999.999\n        cmax = 99999.999\n\n        use_box = False\n        if 'dock_config' in params:\n            box_center, box_size = self.read_dock_config(params['dock_config'])\n            box_min = box_center - box_size/2\n            box_max = box_center + box_size/2\n            cmin = box_min - self.cutoff\n            cmax = box_max + self.cutoff\n            use_box = True\n\n        if 'ligand_file' in params:\n            ligand_file = params['ligand_file']\n            ligand_model_dict = pdbtools.read_coor_pdb(\n                ligand_file, exclude_Hs=True)\n            ligand_dict = ligand_model_dict[1]\n            ligand_coor = list(ligand_dict.values())[0]\n            cmin, cmax = pdbtools.cal_ligand_size(ligand_coor)\n            cmin = cmin - self.cutoff\n            cmax = cmax + self.cutoff\n            use_box = True\n\n        if 'include_hydrophobic' in params:\n            include_hydrophobic = params['include_hydrophobic']\n\n        piscore_receptor = params['piscore_receptor']\n        pf_receptor = params['pf_receptor']\n\n        if piscore_receptor is not None:\n            ms = pybel.readfile('pdb', piscore_receptor)\n            m_protein = list(ms)[0]\n            receptor_bond_dict = self.get_bond_info(m_protein)\n            PF_dict_protein = self.find_PF(m_protein, receptor_bond_dict,\n                                           is_protein=True)\n            PF_coor_protein = self.find_PF_coor(m_protein, PF_dict_protein,\n                                receptor_bond_dict, is_protein=True)\n            metal_coor = self.find_metal_ion(m_protein, is_protein=True)\n            PF_coor_protein['Metal'] = metal_coor\n            if use_box:\n                self.PF_coor_protein = self.box_protein(\n                    PF_coor_protein, cmin, cmax)\n            else:\n                self.PF_coor_protein = PF_coor_protein\n            if pf_receptor is not None:\n                PF_coor_protein_dict = {0: self.PF_coor_protein}\n                self.write_PF(PF_coor_protein_dict,\n                              pf_receptor, is_protein=True)\n        elif pf_receptor is not None:\n            self.PF_coor_protein = self.read_PF(pf_receptor,\n                                                is_protein=True)[0]\n\n        pinfo_ligand = params['pinfo_ligand']\n        pf_receptor_info = params['pf_receptor_info']\n        if pinfo_ligand is not None:\n            self.use_pinfo = True\n            template_dict = self.find_template(self.PF_coor_protein, pinfo_ligand,\n                                               include_hydrophobic=include_hydrophobic)\n            self.PF_coor_info = self.select_template_protein(self.PF_coor_protein,\n                                                             template_dict, cut_num=1)\n            if pf_receptor_info is not None:\n                PF_coor_info_dict = {0: self.PF_coor_info}\n                self.write_PF(PF_coor_info_dict, pf_receptor_info,\n                              is_protein=True)\n        elif pf_receptor_info is not None:\n            self.use_pinfo = True\n            self.PF_coor_info = self.read_PF(\n                pf_receptor_info, is_protein=True)[0]\n\n    def get_bond_info(self, m):\n        \"\"\"\n            find neighbor atoms in molecule\n            input:\n                m: pybel molecule object\n            output:\n                bond_dict: neighbor atom dictionary\n        \"\"\"\n        bond_dict = dict()\n        mol = m.OBMol\n\n        for i in range(mol.NumBonds()):\n            bb = mol.GetBondById(i)\n            if bb is None:\n                continue\n            begin = bb.GetBeginAtomIdx()\n            end = bb.GetEndAtomIdx()\n            if begin not in bond_dict:\n                bond_dict[begin] = [end]\n            else:\n                bond_dict[begin] += [end]\n            if end not in bond_dict:\n                bond_dict[end] = [begin]\n            else:\n                bond_dict[end] += [begin]\n        return bond_dict\n\n    def find_PF(self, m, bond_dict, is_protein=False):\n        \"\"\"\n            Find pharmacophoric features\n            input:\n                m: pybel molecule object\n                is_protein: protein or not\n            output: PF dictionary\n        \"\"\"\n        PF_dict = dict()\n        atoms = m.atoms\n#        bond_dict = self.get_bond_info(m)\n\n        # search pharmacophoric feature using SMARTS pattern\n        for feature_type in self.feature_type_list:\n            patterns = self.SMARTS_pattern_dict[feature_type]\n            PF_dict[feature_type] = list()\n            pattern_keys = sorted(patterns.keys())\n            for pattern_idx in pattern_keys:\n                smarts_pattern = patterns[pattern_idx]\n                smarts = pybel.Smarts(smarts_pattern)\n                atom_idx_group_list = smarts.findall(m)\n                Nfeatures = len(atom_idx_group_list)\n                for k in range(Nfeatures):\n                    atom_idx_group = atom_idx_group_list[k]\n\n                    fea_dict = dict()\n                    fea_dict['atom_idx_group'] = atom_idx_group\n                    fea_dict['pattern_idx'] = pattern_idx\n                    if feature_type == 'HBD':\n                        h_atoms_idx = list()\n                        atom_idx = atom_idx_group[0]\n                        neighbor_atoms_idx = bond_dict[atom_idx]\n                        for neighbor_atom_idx in neighbor_atoms_idx:\n                            neighbor_atom = atoms[neighbor_atom_idx - 1]\n                            if neighbor_atom.atomicnum != 1:\n                                continue\n                            h_atoms_idx += [neighbor_atom_idx]\n                        if len(h_atoms_idx) == 0:\n                            continue\n                        fea_dict['h_atoms_idx'] = h_atoms_idx\n\n                    atom_idx = atom_idx_group[0]\n                    atom = atoms[atom_idx-1]\n                    fea_dict['atom_type'] = atom.type\n                    if is_protein:\n                        residue = atom.residue\n                        chain_id = residue.OBResidue.GetChain()\n                        fea_dict['chain_id'] = chain_id\n                        residue_name = residue.name\n                        fea_dict['residue_name'] = residue_name\n                        residue_num = residue.OBResidue.GetNum()\n                        fea_dict['residue_num'] = residue_num\n                        fea_dict['weight'] = 1.0\n\n                    PF_dict[feature_type] += [fea_dict]\n\n        return PF_dict\n\n    def find_PF_coor(self, m, PF_dict, bond_dict, is_protein=False):\n        \"\"\"\n            Find pharmacophoric features\n            input:\n                m: pybel molecule object\n                PF_dict: pharmacophoric feature dictionary\n                is_protein: True or False\n            output:\n                PF_coor: dictionary\n        \"\"\"\n\n        atoms = m.atoms\n        PF_coor = dict()\n        for feature_type in self.feature_type_list:\n            if feature_type not in PF_dict:\n                continue\n            fea_dict_list = PF_dict[feature_type]\n            PF_coor[feature_type] = list()\n            Nfeatures = len(fea_dict_list)\n            p00_atoms_old = list()\n            num_member = list()\n            for k in range(Nfeatures):\n                fea_dict = fea_dict_list[k]\n                num_member += [len(fea_dict['atom_idx_group'])]\n            num_member = -np.array(num_member)\n            index = num_member.argsort()\n            for k in index:\n                fea_dict = fea_dict_list[k]\n                atom_idx_group = fea_dict['atom_idx_group']\n                pattern_idx = fea_dict['pattern_idx']\n\n                intersection = set(atom_idx_group).intersection(p00_atoms_old)\n                p00_atoms_old += atom_idx_group\n                if len(intersection) > 0 and feature_type != 'Aromatic':\n                    continue\n\n                pseudo_atom = []\n                for atom_index in atom_idx_group:\n                    coor = np.array(atoms[atom_index - 1].coords)\n                    pseudo_atom += [coor]\n                pseudo_atom = np.array(pseudo_atom)\n                pseudo_atom_coor = pseudo_atom.mean(axis=0)\n\n                fea_dict_new = dict()\n                fea_dict_new['atom_idx_group'] = atom_idx_group\n                fea_dict_new['pattern_idx'] = pattern_idx\n                fea_dict_new['pseudo_atom_coor'] = pseudo_atom_coor\n\n                if feature_type == 'HBD':\n                    h_atoms = list()\n                    atom_idx = atom_idx_group[0]\n                    neighbor_heavy_atom_list = list()\n                    neighbor_atoms_idx = bond_dict[atom_idx]\n                    neighbor_atom_list = list()\n                    for neighbor_atom_idx in neighbor_atoms_idx:\n                        neighbor_atom = atoms[neighbor_atom_idx - 1]\n                        if neighbor_atom.atomicnum == 1:\n                            continue\n                        nei_coor = np.array(atoms[neighbor_atom_idx - 1].coords)\n                        neighbor_atom_list += [[neighbor_atom_idx, nei_coor]]\n\n                    h_atoms_idx = fea_dict['h_atoms_idx']\n                    num_neighbor_atom = len(neighbor_atom_list)\n                    for h_atom_idx in h_atoms_idx:\n                        h_coor = np.array(atoms[h_atom_idx - 1].coords)\n                        h_atoms += [[h_atom_idx, h_coor]]\n                        #if len(neighbor_atom_list)==1:\n                            #nei_coor = neighbor_atom_list[0][1]\n                            #vec_a = pseudo_atom_coor - nei_coor\n                            #vec_b = h_coor - pseudo_atom_coor\n                            #vec_c = h_coor - nei_coor\n                            #a = np.linalg.norm(vec_a)\n                            #b = np.linalg.norm(vec_b)\n                            #c = np.linalg.norm(vec_c)\n                            #d = (c**2 - a**2 - b**2)/(2*a**2)\n                            #m_coor = pseudo_atom_coor + vec_a * d/a\n                            #h_coor2 = h_coor + 2 * (m_coor - h_coor)\n                            #h_atoms += [[h_atom_idx, h_coor2]]\n\n                    fea_dict_new['h_atoms'] = h_atoms\n                    fea_dict_new['num_neighbor_atom'] = num_neighbor_atom\n\n\n\n                elif feature_type == 'Aromatic':\n                    v_a = pseudo_atom[1] - pseudo_atom[0]\n                    v_b = pseudo_atom[2] - pseudo_atom[1]\n                    v_c = np.cross(v_a, v_b)\n                    v_n = v_c / np.linalg.norm(v_c)\n                    fea_dict_new['v_n'] = v_n\n                fea_dict_new['atom_type'] = fea_dict['atom_type']\n                if is_protein:\n                    fea_dict_new['chain_id'] = fea_dict['chain_id']\n                    fea_dict_new['residue_name'] = fea_dict['residue_name']\n                    fea_dict_new['residue_num'] = fea_dict['residue_num']\n                    fea_dict_new['weight'] = fea_dict['weight']\n\n                PF_coor[feature_type] += [fea_dict_new]\n\n        return PF_coor\n\n    def find_metal_ion(self, m, is_protein=True):\n        \"\"\"\n            input:\n                m: pybel molecule object\n                is_protein: True or False\n            output:\n                metal_coor: list\n        \"\"\"\n        metal_coor = list()\n        atoms = m.atoms\n        for atom in atoms:\n            atomic_num = atom.atomicnum\n\n            if atomic_num not in self.metal_atomic_name_dict:\n                continue\n            atomic_name = self.metal_atomic_name_dict[atomic_num]\n            atom_idx = atom.idx\n            atom_idx_group = (atom_idx,)\n            coor = np.array(atom.coords)\n            if atomic_name not in self.metal_name_dict:\n                continue\n            pattern_idx = self.metal_name_dict[atomic_name]\n\n            fea_dict = dict()\n            fea_dict['atom_type'] = atom.type\n            fea_dict['atom_idx_group'] = atom_idx_group\n            fea_dict['pattern_idx'] = pattern_idx\n            fea_dict['pseudo_atom_coor'] = coor\n            if is_protein:\n                residue = atom.residue\n                chain_id = residue.OBResidue.GetChain()\n                fea_dict['chain_id'] = chain_id\n                residue_name = residue.name\n                fea_dict['residue_name'] = residue_name\n                residue_num = residue.OBResidue.GetNum()\n                fea_dict['residue_num'] = residue_num\n                fea_dict['weight'] = 1.0\n\n            metal_coor += [fea_dict]\n\n        return metal_coor\n\n    def find_mba(self, m, is_protein=False):\n        \"\"\"\n            metal binding atom for ligand\n            input:\n                m: pybel molecule object\n                is_protein: True or False\n            output:\n                mba_coor: list\n        \"\"\"\n\n        mba_coor = list()\n        atoms = m.atoms\n        for atom in atoms:\n            atom_idx = atom.idx\n            atomic_num = atom.atomicnum\n            if atomic_num != 7 and atomic_num != 8 and atomic_num != 16:\n                continue\n\n            # if atom.formalcharge>0:\n            #    continue\n            # Excluded because protonation state calculation is incomplete\n\n            atom_idx_group = (atom_idx,)\n            coor = np.array(atom.coords)\n            pattern_idx = self.metal_bind_name_dict[atomic_num]\n\n            fea_dict = dict()\n            fea_dict['atom_type'] = atom.type\n            fea_dict['atom_idx_group'] = atom_idx_group\n            fea_dict['pattern_idx'] = pattern_idx\n            fea_dict['pseudo_atom_coor'] = coor\n            if is_protein:\n                residue = atom.residue\n                chain_id = residue.OBResidue.GetChain()\n                fea_dict['chain_id'] = chain_id\n                residue_name = residue.name\n                fea_dict['residue_name'] = residue_name\n                residue_num = residue.OBResidue.GetNum()\n                fea_dict['residue_num'] = residue_num\n                fea_dict['weight'] = 1.0\n            mba_coor += [fea_dict]\n\n        return mba_coor\n\n    def draw_ligand(self, m_ligand, PF_dict, output_name, size):\n        type_list = self.feature_type_list\n        patom_list = list()\n        for fea in type_list:\n            patoms = list()\n            fff = PF_dict[fea]\n            for ff in fff:\n                atom_idx_group = ff[0]\n                for idx in atom_idx_group:\n                    patoms += [idx-1]\n            patom_list += [patoms]\n        m_ligand_noH = Chem.RemoveHs(m_ligand)\n        m_ligand_noH.RemoveConformer(0)\n        mol_list = [m_ligand_noH]*6\n        img = Draw.MolsToGridImage(mol_list, legends=type_list,\n                                   highlightAtomLists=patom_list,\n                                   subImgSize=size, molsPerRow=2)\n        img.save(output_name)\n\n    def box_protein(self, PF_coor_protein, cmin, cmax):\n        \"\"\"\n            select PF of PF_coor_protein in the box\n            input:\n                PF_coor_protein: dict\n                cmin : np.array\n                cmax : np.array\n            output:\n                PF_coor_box: dict\n        \"\"\"\n\n        type_list = self.feature_type_list + ['Metal']\n        PF_coor_box = dict()\n        for fea in type_list:\n            if fea not in PF_coor_protein:\n                continue\n            fea_dict_list = PF_coor_protein[fea]\n            PF_coor_box[fea] = list()\n            for fea_dict in fea_dict_list:\n                pseudo_atom_coor = fea_dict['pseudo_atom_coor']\n                if (pseudo_atom_coor > cmax).any():\n                    continue\n                elif (pseudo_atom_coor < cmin).any():\n                    continue\n                PF_coor_box[fea] += [fea_dict]\n        return PF_coor_box\n\n    def find_template(self, PF_coor_protein, template_ligand_file, include_hydrophobic=False):\n        template_dict = dict()\n        feature_type_list_receptor = self.feature_type_list + ['Metal']\n        for feature_type_receptor in feature_type_list_receptor:\n            if not include_hydrophobic and feature_type_receptor == 'Hydrophobic':\n                continue\n            template_dict[feature_type_receptor] = dict()\n\n        file_format = template_ligand_file.split('.')[-1]\n        ms = list(pybel.readfile(file_format, template_ligand_file))\n        m_ligand = ms[0]\n        ligand_bond_dict = self.get_bond_info(m_ligand)\n        PF_dict_ligand = self.find_PF(m_ligand, ligand_bond_dict)\n\n        num_model = len(ms)\n        if num_model > 1:\n            num_model = num_model - 1\n        PF_coor_ligand_dict = dict()\n        interaction_dict = dict()\n        model_idx = 0\n        m_ligand = ms[model_idx]\n        PF_coor_ligand = self.find_PF_coor(m_ligand, PF_dict_ligand, ligand_bond_dict)\n        mba_coor = self.find_mba(m_ligand, is_protein=False)\n        PF_coor_ligand['MBA'] = mba_coor\n\n        PF_coor_ligand_dict[model_idx] = PF_coor_ligand\n        interaction = self.find_interaction(PF_coor_protein, PF_coor_ligand,\n                                            ligand_bond_dict)\n        interaction_dict[model_idx] = interaction\n        total_rec_pf_dict = self.count_interaction_receptor(interaction_dict)\n        rec_pf_dict = total_rec_pf_dict[0]\n        for feature_type_receptor in rec_pf_dict.keys():\n            if not include_hydrophobic and feature_type_receptor == 'Hydrophobic':\n                continue\n            rec_pf = rec_pf_dict[feature_type_receptor]\n            atom_idx_group_list = rec_pf.keys()\n            for atom_idx_group in atom_idx_group_list:\n                if atom_idx_group not in template_dict[feature_type_receptor]:\n                    template_dict[feature_type_receptor][atom_idx_group] = 0\n                template_dict[feature_type_receptor][atom_idx_group] += 1\n        return template_dict\n\n    def select_template_protein(self, PF_coor_protein, template_dict,\n                                cut_num=0):\n        \"\"\"\n            select PF of PF_coor_protein in template\n            input:\n                PF_coor_protein: dict\n                template_dict: dict\n            output:\n                PF_coor_info: dict\n        \"\"\"\n        type_list = self.feature_type_list + ['Metal']\n        PF_coor_info = dict()\n        for fea in type_list:\n            if fea not in PF_coor_protein:\n                continue\n            if fea not in template_dict:\n                continue\n            fea_dict_list = PF_coor_protein[fea]\n            PF_coor_info[fea] = list()\n            for fea_dict in fea_dict_list:\n                atom_idx_group = fea_dict['atom_idx_group']\n                if atom_idx_group not in template_dict[fea]:\n                    continue\n                num_in_template = template_dict[fea][atom_idx_group]\n                if num_in_template < cut_num:\n                    continue\n                PF_coor_info[fea] += [fea_dict]\n        return PF_coor_info\n\n    def find_interaction(self, PF_coor_protein, PF_coor_ligand,\n                         ligand_bond_dict):\n        \"\"\"\n            find pharmacophoric interaction\n            input:\n                PF_coor_protein: dict\n                PF_coor_ligand: dict\n                ligand_bond_dict: dict\n            output:\n                interaction: dict\n        \"\"\"\n        type_list = self.feature_type_list + ['MBA']\n#        type_list = self.feature_type_list\n\n        coor_ligand_list = list()\n        for fea_ligand in type_list:\n            if fea_ligand not in PF_coor_ligand:\n                continue\n            fea_dict_list_ligand = PF_coor_ligand[fea_ligand]\n            for fea_dict_ligand in fea_dict_list_ligand:\n                coor_ligand = fea_dict_ligand['pseudo_atom_coor']\n                coor_ligand_list.append(coor_ligand)\n        coor_ligand_list = np.array(coor_ligand_list)\n        cmin = coor_ligand_list.min(axis=0) - self.cutoff\n        cmax = coor_ligand_list.max(axis=0) + self.cutoff\n\n        PF_coor_protein_box = self.box_protein(PF_coor_protein, cmin, cmax)\n\n        interaction = dict()\n        for fea_ligand in type_list:\n            if fea_ligand not in interaction:\n                interaction[fea_ligand] = dict()\n            if fea_ligand not in PF_coor_ligand:\n                continue\n            fea_dict_list_ligand = PF_coor_ligand[fea_ligand]\n            cfea_list = self.complementary_feature[fea_ligand]\n            for fea_dict_ligand in fea_dict_list_ligand:\n                idx_ligand = fea_dict_ligand['atom_idx_group']\n                pattern_ligand = fea_dict_ligand['pattern_idx']\n                coor_ligand = fea_dict_ligand['pseudo_atom_coor']\n                for cfea_t in cfea_list:\n                    fea_protein = cfea_t[0]\n                    if fea_protein not in interaction[fea_ligand]:\n                        interaction[fea_ligand][fea_protein] = list()\n                    pair_cutoff = cfea_t[1]\n                    if fea_protein not in PF_coor_protein_box:\n                        continue\n                    fea_dict_list_protein = PF_coor_protein_box[fea_protein]\n                    for fea_dict_protein in fea_dict_list_protein:\n                        idx_protein = fea_dict_protein['atom_idx_group']\n                        pattern_protein = fea_dict_protein['pattern_idx']\n                        coor_protein = fea_dict_protein['pseudo_atom_coor']\n\n                        r_lp = coor_protein - coor_ligand\n                        dist_lp = np.linalg.norm(r_lp)\n#                        if dist_lp > self.cutoff:\n                        if dist_lp > pair_cutoff:\n                            continue\n\n                        interact_ij = dict()\n                        interact_ij['idx_ligand'] = idx_ligand\n                        interact_ij['idx_protein'] = idx_protein\n                        interact_ij['pattern_ligand'] = pattern_ligand\n                        interact_ij['pattern_protein'] = pattern_protein\n\n                        interact_ij['dist_lp'] = dist_lp\n                        interact_ij['chain_id'] = fea_dict_protein['chain_id']\n                        interact_ij['residue_name'] = fea_dict_protein['residue_name']\n                        interact_ij['residue_num'] = fea_dict_protein['residue_num']\n                        interact_ij['weight'] = fea_dict_protein['weight']\n\n                        if fea_ligand == 'HBD' and fea_protein == 'HBA':\n                            num_neighbor_atom = fea_dict_ligand['num_neighbor_atom']\n                            donor_hydrogen_list = fea_dict_ligand['h_atoms']\n                            if num_neighbor_atom <= 1:\n                                theta = 0\n                                interact_ij['theta'] = theta\n                            else:\n                                dist_ah = 100.0\n                                for donor_hydrogen in donor_hydrogen_list:\n                                    hydrogen_coor0 = donor_hydrogen[1]\n                                    dist_ah0 = np.linalg.norm(\n                                        hydrogen_coor0 - coor_protein)\n                                    if dist_ah0 < dist_ah:\n                                        dist_ah = dist_ah0\n                                        hydrogen_coor = hydrogen_coor0\n                                dist_dh = np.linalg.norm(\n                                    hydrogen_coor - coor_ligand)\n                                theta = cal_angle_from_points(\n                                    dist_lp, dist_dh, dist_ah)\n                                if theta < 0.6*np.pi:\n                                    continue\n                                interact_ij['theta'] = theta\n\n                        elif fea_ligand == 'HBA' and fea_protein == 'HBD':\n                            num_neighbor_atom = fea_dict_protein['num_neighbor_atom']\n                            donor_hydrogen_list = fea_dict_protein['h_atoms']\n                            if num_neighbor_atom <= 1:\n                                theta = 0\n                                interact_ij['theta'] = theta\n                            else:\n                                dist_ah = 100.0\n                                for donor_hydrogen in donor_hydrogen_list:\n                                    hydrogen_coor0 = donor_hydrogen[1]\n                                    dist_ah0 = np.linalg.norm(\n                                        hydrogen_coor0 - coor_ligand)\n                                    if dist_ah0 < dist_ah:\n                                        dist_ah = dist_ah0\n                                        hydrogen_coor = hydrogen_coor0\n                                dist_dh = np.linalg.norm(\n                                    hydrogen_coor - coor_protein)\n                                theta = cal_angle_from_points(\n                                    dist_lp, dist_dh, dist_ah)\n                                if theta < 0.6*np.pi:\n                                    continue\n                                interact_ij['theta'] = theta\n\n                        elif fea_ligand == 'Aromatic' and fea_protein == 'Cation':\n                            n_vector_ligand = fea_dict_ligand['v_n']\n                            n_vector_lp = r_lp/dist_lp\n                            theta = np.abs(cal_angle_from_vectors(\n                                           n_vector_ligand, n_vector_lp))\n                            if theta > np.pi/2:\n                                theta = np.pi-theta\n                            if theta > 0.5*np.pi/2:\n                                continue\n                            interact_ij['theta'] = theta\n\n                        elif fea_ligand == 'Cation' and fea_protein == 'Aromatic':\n                            n_vector_protein = fea_dict_protein['v_n']\n                            n_vector_lp = r_lp/dist_lp\n                            theta = np.abs(cal_angle_from_vectors(\n                                           n_vector_protein, n_vector_lp))\n                            if theta > np.pi/2:\n                                theta = np.pi-theta\n                            if theta > 0.5*np.pi/2:\n                                continue\n                            interact_ij['theta'] = theta\n\n                        elif fea_ligand == 'Aromatic' and fea_protein == 'Aromatic':\n                            n_vector_ligand = fea_dict_ligand['v_n']\n                            n_vector_protein = fea_dict_protein['v_n']\n                            n_vector_lp = r_lp/dist_lp\n                            theta = cal_angle_from_vectors(\n                                n_vector_ligand, n_vector_protein)\n                            if theta > np.pi/2:\n                                theta = np.pi-theta\n                            interact_ij['theta'] = theta\n\n                            alpha = np.abs(cal_angle_from_vectors(\n                                           n_vector_ligand, n_vector_lp))\n#                            dist_v = dist_lp * np.cos(alpha)\n#                            dist_h = dist_lp * np.sin(alpha)\n#                            print(np.sqrt(dist_v*dist_v+dist_h*dist_h), dist_lp)\n#                            interact_ij['dist_v'] = dist_v\n#                            interact_ij['dist_h'] = dist_h\n                            if theta > 0.4*np.pi/2 and theta < 0.8*np.pi/2:\n                                continue\n                            interact_ij['alpha'] = alpha\n\n                        elif fea_ligand == 'MBA' and fea_protein == 'Metal':\n                            if pattern_ligand not in self.metal_interaction_cutoff:\n                                continue\n                            if pattern_protein not in self.metal_interaction_cutoff[pattern_ligand]:\n                                continue\n                            metal_cutoff = self.metal_interaction_cutoff[\n                                pattern_ligand][pattern_protein]\n                            if dist_lp > metal_cutoff:\n                                continue\n                        interaction[fea_ligand][fea_protein] += [interact_ij]\n\n        if 'MBA' in interaction:\n            if 'Metal' in interaction['MBA']:\n                metal_interaction = interaction['MBA']['Metal']\n                d_list = list()\n                d_list = np.array([x['dist_lp'] for x in metal_interaction])\n                idx_sorted = np.argsort(d_list)\n\n                metal_interaction_new = list()\n                batom_idx = list()\n                for idx in idx_sorted:\n                    interact_ij = metal_interaction[idx]\n                    idx_ligand = interact_ij['idx_ligand'][0]\n#                    dist_lp = interact_ij['dist_lp']\n                    neighbor_atoms_idx = ligand_bond_dict[idx_ligand]\n                    neighbor_check = False\n                    for neighbor_atom_idx in neighbor_atoms_idx:\n\n                        if neighbor_atom_idx in batom_idx:\n                            neighbor_check = True\n                    if not neighbor_check:\n                        metal_interaction_new += [interact_ij]\n                        batom_idx += [idx_ligand]\n\n                interaction['MBA']['Metal'] = metal_interaction_new\n\n        return interaction\n\n    def write_PF(self, PF_coor_dict, out_file, is_protein=False):\n        \"\"\"\n            write pharmacophoric feature\n            input:\n                PF_coor_dict: dict\n                out_file: filename, str\n                is_protein: bool\n        \"\"\"\n\n        if is_protein:\n            feature_type_list = self.feature_type_list + ['Metal']\n        else:\n            feature_type_list = self.feature_type_list + ['MBA']\n        fp = open(out_file, 'w')\n        line_out = 'feature_type:atom_idx_group:pattern_idx:pseudo_atom_coor'\n        line_out += ':atom_type:etc'\n        if is_protein:\n            line_out += ':chain_id:residue_name:residue_num:weight'\n        line_out += '\\n'\n        fp.write(line_out)\n        model_idx_list = PF_coor_dict.keys()\n        num_model = len(model_idx_list)\n        for model_idx in model_idx_list:\n            PF_coor = PF_coor_dict[model_idx]\n            if num_model > 1:\n                line_out = 'MODEL %d\\n' % (model_idx + 1)\n                fp.write(line_out)\n            for feature_type in feature_type_list:\n                if feature_type not in PF_coor:\n                    continue\n                fea_dict_list = PF_coor[feature_type]\n                for fea_dict in fea_dict_list:\n                    line_out = '%s' % feature_type\n#                    line_out += ':%s' % (str(fea_dict['atom_idx_group']))\n                    idx_line = ''\n                    for atom_idx in fea_dict['atom_idx_group']:\n                        idx_line += '%d,' % atom_idx\n                    line_out += ':(%s)' % idx_line.strip(',')\n\n                    line_out += ':%s' % (fea_dict['pattern_idx'])\n                    coor = fea_dict['pseudo_atom_coor']\n                    line_out += ':(%.3f,%.3f,%.3f)' % (\n                        coor[0], coor[1], coor[2])\n                    line_out += ':%s' % (fea_dict['atom_type'])\n\n                    if 'h_atoms' in fea_dict:\n                        hatoms = fea_dict['h_atoms']\n                        hatom_line = ''\n                        if 'num_neighbor_atom' in fea_dict:\n                            num_neighbor_atom = fea_dict['num_neighbor_atom']\n                            hatom_line += '%d;' %num_neighbor_atom\n                        for hatom in hatoms:\n                            line_f = '%d=(%.3f,%.3f,%.3f);'\n                            hatom_line += line_f % (hatom[0], hatom[1][0],\n                                                    hatom[1][1], hatom[1][2])\n                        line_out += ':%s' % hatom_line.strip(';')\n\n                    elif 'v_n' in fea_dict:\n                        coor_v_n = fea_dict['v_n']\n                        line_out += ':(%.3f,%.3f,%.3f)' % (\n                            coor_v_n[0], coor_v_n[1], coor_v_n[2])\n\n                    else:\n                        line_out += ':'\n\n                    if is_protein:\n                        line_out += ':%s' % (fea_dict['chain_id'])\n                        line_out += ':%s' % (fea_dict['residue_name'])\n                        line_out += ':%d' % (fea_dict['residue_num'])\n                        line_out += ':%.3f' % (fea_dict['weight'])\n\n                    line_out += '\\n'\n                    fp.write(line_out)\n        fp.close()\n\n    def read_PF(self, feature_file, is_protein=False):\n        PF_coor_dict = dict()\n        fp = open(feature_file)\n        lines = fp.readlines()\n        fp.close()\n\n        model_idx = 0\n        PF_coor_dict[model_idx] = dict()\n\n        for line in lines:\n            if line.startswith('feature_type'):\n                # title = line.strip().split(':')\n                continue\n\n            if line.startswith('MODEL'):\n                model_idx = int(line.strip().split()[1]) - 1\n                fea_dict = dict()\n                if model_idx not in PF_coor_dict:\n                    PF_coor_dict[model_idx] = dict()\n                continue\n            lis = line.strip().split(':')\n            if len(lis) < 1:\n                continue\n            fea_dict = dict()\n            feature_type = lis[0]\n            atom_idx_group = lis[1]\n            pattern_idx = lis[2]\n            pseudo_atom_coor = lis[3]\n            atom_type = lis[4]\n            etc = lis[5]\n            if feature_type not in PF_coor_dict[model_idx]:\n                PF_coor_dict[model_idx][feature_type] = list()\n\n            fea_dict['feature_type'] = feature_type\n            aline = atom_idx_group.lstrip('(').rstrip(')')\n            fea_dict['atom_idx_group'] = np.array(aline.split(','), dtype=int)\n            fea_dict['pattern_idx'] = int(pattern_idx)\n            coor = pseudo_atom_coor.lstrip('(').rstrip(')').split(',')\n            fea_dict['pseudo_atom_coor'] = np.array(coor, dtype=np.float32)\n            fea_dict['atom_type'] = atom_type\n            if feature_type == 'HBD':\n                hline_list = etc.split(';')\n                h_list = list()\n                num_neighbor_atom = float(hline_list[0])\n                fea_dict['num_neighbor_atom'] = num_neighbor_atom\n                for hline in hline_list[1:]:\n                    aa = hline.split('=')\n                    h_idx = int(aa[0])\n                    h_coor = aa[1].lstrip('(').rstrip(')').split(',')\n                    h_list += [[h_idx, np.array(h_coor, dtype=np.float32)]]\n                    fea_dict['h_atoms'] = h_list\n            if feature_type == 'Aromatic':\n                v_n = etc.lstrip('(').rstrip(')').split(',')\n                fea_dict['v_n'] = np.array(v_n, dtype=np.float32)\n            if is_protein:\n                chain_id = lis[6]\n                residue_name = lis[7]\n                residue_num = lis[8]\n                fea_dict['chain_id'] = chain_id\n                fea_dict['residue_name'] = residue_name\n                fea_dict['residue_num'] = int(residue_num)\n                if len(lis) >= 10:\n                    weight = lis[9]\n                    fea_dict['weight'] = float(weight)\n                else:\n                    fea_dict['weight'] = 1.0\n\n            PF_coor_dict[model_idx][feature_type] += [fea_dict]\n\n        return PF_coor_dict\n\n    def write_interaction(self, interaction_dict, out_file):\n        \"\"\"\n            write pharmacophoric interaction\n            input:\n                interaction_dict: dict()\n                out_file: str\n        \"\"\"\n        fp = open(out_file, 'w')\n        line_out = 'feature_type_ligand:feature_type_protein'\n        line_out += ':atom_idx_group_ligand:atom_idx_group_protein'\n        line_out += ':pattern_ligand:pattern_protein'\n        line_out += ':chain_id:residue_name:residue_num'\n        line_out += ':dist_lp:theta:alpha:weight\\n'\n        fp.write(line_out)\n\n        model_idx_list = interaction_dict.keys()\n        num_model = len(model_idx_list)\n        for model_idx in model_idx_list:\n            interaction = interaction_dict[model_idx]\n            if num_model > 1:\n                line_out = 'MODEL %d\\n' % (model_idx + 1)\n                fp.write(line_out)\n\n            for feature_type_ligand in interaction.keys():\n                inter_i = interaction[feature_type_ligand]\n                for feature_type_protein in inter_i.keys():\n                    inter_ij_list = inter_i[feature_type_protein]\n                    for inter_ij in inter_ij_list:\n                        line_out = '%s' % feature_type_ligand\n                        line_out += ':%s' % feature_type_protein\n\n                        idx_line = ''\n                        for idx in inter_ij['idx_ligand']:\n                            idx_line += '%d,' % (idx)\n                        line_out += ':(%s)' % (idx_line.strip(','))\n\n                        idx_line = ''\n                        for idx in inter_ij['idx_protein']:\n                            idx_line += '%d,' % (idx)\n                        line_out += ':(%s)' % (idx_line.strip(','))\n                        line_out += ':%s' % (inter_ij['pattern_ligand'])\n                        line_out += ':%s' % (inter_ij['pattern_protein'])\n\n                        line_out += ':%s' % (inter_ij['chain_id'])\n                        line_out += ':%s' % (inter_ij['residue_name'])\n                        line_out += ':%d' % (inter_ij['residue_num'])\n                        line_out += ':%.3f' % (inter_ij['dist_lp'])\n                        if 'theta' in inter_ij:\n                            line_out += ':%.3f' % (inter_ij['theta'])\n                        else:\n                            line_out += ':'\n                        if 'alpha' in inter_ij:\n                            line_out += ':%.3f' % (inter_ij['alpha'])\n                        else:\n                            line_out += ':'\n                        line_out += ':%.3f' % (inter_ij['weight'])\n\n                        line_out += '\\n'\n                        fp.write(line_out)\n\n        fp.close()\n\n    def count_interaction_receptor(self, interaction_dict):\n\n        total_rec_pf_dict = dict()\n        model_idx_list = interaction_dict.keys()\n        feature_type_list_receptor = self.feature_type_list + ['Metal']\n        feature_type_list_ligand = self.feature_type_list + ['MBA']\n\n        for model_idx in model_idx_list:\n            line_out_title = 'Model_idx'\n            interaction = interaction_dict[model_idx]\n\n            rec_pf_dict = dict()\n            for feature_type_ligand in feature_type_list_ligand:\n                line_out_title += ' %s' % (feature_type_ligand)\n                if feature_type_ligand not in interaction:\n                    continue\n                inter_i = interaction[feature_type_ligand]\n                for feature_type_protein in feature_type_list_receptor:\n                    if feature_type_protein not in rec_pf_dict:\n                        rec_pf_dict[feature_type_protein] = dict()\n                    if feature_type_protein not in inter_i.keys():\n                        continue\n                    inter_ij_list = inter_i[feature_type_protein]\n                    for inter_ij in inter_ij_list:\n                        idx_protein = inter_ij['idx_protein']\n                        if idx_protein not in rec_pf_dict[feature_type_protein]:\n                            rec_pf_dict[feature_type_protein][idx_protein] = 0\n                        rec_pf_dict[feature_type_protein][idx_protein] += 1\n            total_rec_pf_dict[model_idx] = rec_pf_dict\n\n        return total_rec_pf_dict\n\n    def print_interaction_receptor(self, total_rec_pf_dict):\n        line_out_total = ''\n        model_idx_list = total_rec_pf_dict.keys()\n        feature_type_list_receptor = self.feature_type_list + ['Metal']\n\n        line_out_title = 'Model_idx'\n        for feature_type_receptor in feature_type_list_receptor:\n            line_out_title += ' %s' % (feature_type_receptor)\n        line_out_total += line_out_title + '\\n'\n\n        for model_idx in model_idx_list:\n            line_out_value = '%d' % (model_idx + 1)\n            rec_pf_dict = total_rec_pf_dict[model_idx]\n            for feature_type_protein in feature_type_list_receptor:\n                if feature_type_protein in rec_pf_dict:\n                    count = len(rec_pf_dict[feature_type_protein].keys())\n                else:\n                    count = 0\n                line_out_value += ' %d' % (count)\n            line_out_total += line_out_value + '\\n'\n\n        return line_out_total\n\n    def count_interaction_ligand(self, interaction_dict):\n        total_lig_pf_dict = dict()\n        model_idx_list = interaction_dict.keys()\n        feature_type_list = self.feature_type_list + ['MBA']\n\n        for model_idx in model_idx_list:\n            interaction = interaction_dict[model_idx]\n            lig_pf_dict = dict()\n            for feature_type_ligand in feature_type_list:\n                if feature_type_ligand not in interaction:\n                    continue\n                inter_i = interaction[feature_type_ligand]\n                lig_pf_dict[feature_type_ligand] = dict()\n                for feature_type_protein in inter_i.keys():\n                    inter_ij_list = inter_i[feature_type_protein]\n                    for inter_ij in inter_ij_list:\n                        idx_ligand = inter_ij['idx_ligand']\n                        if idx_ligand not in lig_pf_dict[feature_type_ligand]:\n                            lig_pf_dict[feature_type_ligand][idx_ligand] = 0\n                        lig_pf_dict[feature_type_ligand][idx_ligand] += 1\n            total_lig_pf_dict[model_idx] = lig_pf_dict\n\n        return total_lig_pf_dict\n\n    def print_interaction_ligand(self, total_lig_pf_dict):\n        line_out_total = ''\n        model_idx_list = total_lig_pf_dict.keys()\n        feature_type_list = self.feature_type_list + ['MBA']\n\n        line_out_title = 'Model_idx'\n        for feature_type_ligand in feature_type_list:\n            line_out_title += ' %s' % (feature_type_ligand)\n        line_out_total += line_out_title + '\\n'\n\n        for model_idx in model_idx_list:\n            line_out_value = '%d' % (model_idx + 1)\n            lig_pf_dict = total_lig_pf_dict[model_idx]\n            for feature_type_ligand in feature_type_list:\n                if feature_type_ligand in lig_pf_dict:\n                    count = len(lig_pf_dict[feature_type_ligand].keys())\n                else:\n                    count = 0\n                line_out_value += ' %d' % (count)\n            line_out_total += line_out_value + '\\n'\n\n        return line_out_total\n\n    def count_interaction(self, interaction_dict, use_weight_pis=True,\n                          include_hydrophobic=True):\n        \"\"\"\n            input:\n                interaction_dict: dict()\n            output:\n                total_count_dict: dict()\n        \"\"\"\n\n        total_count_dict = dict()\n\n        feature_type_list = self.feature_type_list + ['MBA']\n        model_idx_list = interaction_dict.keys()\n        for model_idx in model_idx_list:\n            interaction = interaction_dict[model_idx]\n            count_dict = dict()\n            w_count_dict = dict()\n            for feature_type_ligand in feature_type_list:\n                cfea_list = self.complementary_feature[feature_type_ligand]\n                for cfea in cfea_list:\n                    feature_type_protein = cfea[0]\n\n                    key = '%s:%s' % (feature_type_ligand, feature_type_protein)\n                    if key not in count_dict:\n                        count_dict[key] = 0\n                        w_count_dict[key] = 0\n                    if feature_type_ligand not in interaction:\n                        continue\n                    inter_i = interaction[feature_type_ligand]\n                    if feature_type_protein not in inter_i:\n                        continue\n                    if ((not include_hydrophobic)\n                            and feature_type_protein == 'Hydrophobic'):\n                        continue\n\n                    inter_ij_list = inter_i[feature_type_protein]\n                    for inter_ij in inter_ij_list:\n                        count_dict[key] += 1\n                        weight = inter_ij['weight']\n                        w_count_dict[key] += weight\n\n            score = 0\n            for key in self.interaction_feature:\n                if use_weight_pis:\n                    score += w_count_dict[key]*self.weight_pis[key]\n                else:\n                    score += w_count_dict[key]\n            if use_weight_pis:\n                score += self.bias_pis\n\n            count_dict['Score'] = score\n\n            total_count_dict[model_idx] = count_dict\n\n        return total_count_dict\n\n    def print_interaction(self, total_count_dict, total_count_info_dict,\n                          use_pinfo, print_option=1):\n        \"\"\"\n            input:\n                total_count_dict: from count_interaction\n                print_option:\n                    if 1, print interction in one line for one model.\n                    if 2, print interaction in multi lines.\n            output:\n                line_out_total: str\n        \"\"\"\n\n        line_out_total = ''\n\n        model_idx_list = total_count_dict.keys()\n        num_model = len(model_idx_list)\n        if print_option == 1:\n            line_out_title = 'Model_idx PIscore'\n            if use_pinfo:\n                line_out_title += ' Pinfo'\n            for key in self.interaction_feature:\n                line_out_title += ' %s' % (key)\n            line_out_total += line_out_title + '\\n'\n\n        for model_idx in model_idx_list:\n            count_dict = total_count_dict[model_idx]\n            if num_model > 1 and print_option == 2:\n                line_out = 'MODEL %d' % (model_idx + 1)\n                line_out_total += line_out + '\\n'\n            if print_option == 1:\n                line_out_value = '%d' % (model_idx + 1)\n                line_out_value += ' %.4f' % (count_dict['Score'])\n                if use_pinfo:\n                    count_info_dict = total_count_info_dict[model_idx]\n                    line_out_value += ' %.4f' % (count_info_dict['Score'])\n\n            for key in self.interaction_feature:\n                count = count_dict[key]\n                if print_option == 1:\n                    line_out_value += ' %d' % (count)\n\n                if count > 0 and print_option == 2:\n                    line_out = '%s %d\\n' % (key, count)\n                    line_out_total += line_out\n\n            if print_option == 2:\n                line_out = 'PIscore: %.4f\\n' % (count_dict['Score'])\n                if use_pinfo:\n                    count_info_dict = total_count_info_dict[model_idx]\n                    line_out += 'Pinfo %.4f\\n' % (count_info_dict['Score'])\n\n                line_out_total += line_out\n\n            if print_option == 1:\n                line_out_total += line_out_value + '\\n'\n\n        return line_out_total\n\n    def read_dock_config(self, dock_config):\n        fp = open(dock_config)\n        lines = fp.readlines()\n        fp.close()\n\n        for line in lines:\n            lis = line.strip().split('=')\n            if lis[0] == 'center_x':\n                center_x = float(lis[1])\n            elif lis[0] == 'center_y':\n                center_y = float(lis[1])\n            elif lis[0] == 'center_z':\n                center_z = float(lis[1])\n            elif lis[0] == 'size_x':\n                size_x = float(lis[1])\n            elif lis[0] == 'size_y':\n                size_y = float(lis[1])\n            elif lis[0] == 'size_z':\n                size_z = float(lis[1])\n\n        center = np.array((center_x, center_y, center_z), dtype=float)\n        size = np.array((size_x, size_y, size_z), dtype=float)\n        return center, size\n\n    def cal_piscore(self, ligand_file, pf_ligand_file, interaction_file):\n\n        ms = list(pybel.readfile('pdb', ligand_file))\n        num_model = len(ms)\n        if num_model > 1:\n            num_model = num_model - 1\n        if num_model < 1:\n            return None\n\n        m_ligand = ms[0]\n\n        PF_coor_ligand_dict = dict()\n        interaction_dict = dict()\n        if self.use_pinfo:\n            interaction_info_dict = dict()\n        ligand_bond_dict = self.get_bond_info(m_ligand)\n        PF_dict_ligand = self.find_PF(m_ligand, ligand_bond_dict)\n        for model_idx in range(num_model):\n            m_ligand = ms[model_idx]\n            PF_coor_ligand = self.find_PF_coor(m_ligand, PF_dict_ligand, ligand_bond_dict)\n            mba_coor = self.find_mba(m_ligand, is_protein=False)\n            PF_coor_ligand['MBA'] = mba_coor\n            PF_coor_ligand_dict[model_idx] = PF_coor_ligand\n            interaction = self.find_interaction(self.PF_coor_protein,\n                                                PF_coor_ligand,\n                                                ligand_bond_dict)\n\n            interaction_dict[model_idx] = interaction\n            if self.use_pinfo:\n                interaction_info = self.find_interaction(self.PF_coor_info,\n                                                         PF_coor_ligand,\n                                                         ligand_bond_dict)\n                interaction_info_dict[model_idx] = interaction_info\n\n        if pf_ligand_file is not None:\n            self.write_PF(PF_coor_ligand_dict, pf_ligand_file)\n\n        if interaction_file is not None:\n            self.write_interaction(interaction_dict, interaction_file)\n\n        total_count_dict = self.count_interaction(interaction_dict,\n                                                  use_weight_pis=True,\n                                                  include_hydrophobic=True)\n        if self.use_pinfo:\n            total_count_info_dict = self.count_interaction(\n                interaction_info_dict,\n                use_weight_pis=False,\n                include_hydrophobic=True)\n        else:\n            total_count_info_dict = None\n        return total_count_dict, total_count_info_dict\n\n\ndef set_pifinder(args):\n\n    piscore_receptor = args.piscore_receptor\n    pf_receptor = args.pf_receptor\n    pinfo_ligand = args.pinfo_ligand\n    pf_receptor_info = args.pf_receptor_info\n    pi_cutoff = args.pi_cutoff\n    include_hydrophobic = args.include_hydrophobic\n    dock_config = args.dock_config\n\n    params = dict()\n    weight_pis = {\n        'HBD:HBA': 0.129,\n        'HBA:HBD': 0.129,\n        'Anion:Cation': 0.31,\n        'Cation:Anion': 0.31,\n        'Cation:Aromatic': 0.039,\n        'Hydrophobic:Hydrophobic': 0.00585,\n        'Aromatic:Cation': 0.039,\n        'Aromatic:Aromatic': 0.064,\n        'MBA:Metal': 1.0\n    }\n    params['weight_pis'] = weight_pis\n    params['bias_pis'] = 4.0\n    params['cutoff'] = pi_cutoff\n    if dock_config is not None:\n        params['dock_config'] = dock_config\n    params['include_hydrophobic'] = include_hydrophobic\n    params['piscore_receptor'] = piscore_receptor\n    params['pf_receptor'] = pf_receptor\n    params['pinfo_ligand'] = pinfo_ligand\n    params['pf_receptor_info'] = pf_receptor_info\n\n    pharma = Pharmacophore(params)\n\n    return pharma\n\n\ndef main():\n\n    import sys\n    import argparse\n    title_line = 'Fixer for ligand pdb which is converted from pdbqt'\n    parser = argparse.ArgumentParser(description=title_line)\n    parser.add_argument('-r', '--piscore_receptor', required=False,\n                        default=None,\n                        help='input receptor pdb file')\n    parser.add_argument('-p', '--pf_receptor', required=False,\n                        default=None,\n                        help='output for pharmacophoric feature of receptor')\n    parser.add_argument('-t', '--pinfo_ligand', required=False,\n                        default=None, help='pinfo_ligand')\n    parser.add_argument('-u', '--pf_receptor_info', required=False,\n                        default=None,\n                        help='output for template feature of receptor')\n    parser.add_argument('-v', '--dock_config', type=str, required=False,\n                        default=None, help='dock_config_file')\n    parser.add_argument('-m', '--pi_cutoff', type=float, required=False,\n                        default=6.5,\n                        help='pharmacophoric interaction cutoff distance')\n    parser.add_argument('-l', '--ligand_file', required=True,\n                        help='input ligand pdb file')\n    parser.add_argument('-q', '--pf_ligand_file', required=False,\n                        default=None,\n                        help='write pharmacophoric feature of ligand')\n    parser.add_argument('--include_hydrophobic', action='store_true',\n                        required=False,\n                        help='include hydrophobic feature for template')\n    parser.add_argument('-i', '--interaction_file', required=False,\n                        default=None, help='write interaction')\n    parser.add_argument('--print_option', type=int, required=False, default=0,\n                        help='print_option 0:None, 1: one_line, 2: multi_line')\n\n#    draw_ligand = False\n    args = parser.parse_args()\n    if args.piscore_receptor is None and args.pf_receptor is None:\n        parser.print_usage()\n        print('error piscore_receptor and pf_receptor are None')\n        sys.exit()\n\n    pharma = set_pifinder(args)\n    use_pinfo = pharma.use_pinfo\n\n    ligand_file = args.ligand_file\n    pf_ligand_file = args.pf_ligand_file\n    interaction_file = args.interaction_file\n    print_option = args.print_option\n\n    result = pharma.cal_piscore(ligand_file, pf_ligand_file, interaction_file)\n    total_count_dict, total_count_info_dict = result\n\n#    if draw_ligand:\n#        size = (200, 200)\n#        fig_dir = 'fig'\n#        output_name = fig_dir + '/%s.png' % (ligand_file[:-3])\n#        m_rdkit_ligand = Chem.MolFromPDBFile(ligand_file, removeHs=True)\n#        pharma.draw_ligand(m_rdkit_ligand, PF_dict_ligand, output_name, size)\n\n    if print_option > 0:\n        lines_count = pharma.print_interaction(total_count_dict,\n                                               total_count_info_dict,\n                                               use_pinfo,\n                                               print_option=print_option)\n        print(lines_count.rstrip())\n\n\nif __name__ == '__main__':\n    main()\n", "meta": {"hexsha": "201967f4c3d5de52cd204a0e2e45a4acceec0486", "size": 58230, "ext": "py", "lang": "Python", "max_stars_repo_path": "pifinder/pifinder.py", "max_stars_repo_name": "gicsaw/PIFinder", "max_stars_repo_head_hexsha": "fe1dd1a04e9380522e4d201afffd79f7b947f3a8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pifinder/pifinder.py", "max_issues_repo_name": "gicsaw/PIFinder", "max_issues_repo_head_hexsha": "fe1dd1a04e9380522e4d201afffd79f7b947f3a8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pifinder/pifinder.py", "max_forks_repo_name": "gicsaw/PIFinder", "max_forks_repo_head_hexsha": "fe1dd1a04e9380522e4d201afffd79f7b947f3a8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.1228813559, "max_line_length": 100, "alphanum_fraction": 0.5093250902, "include": true, "reason": "import numpy", "num_tokens": 13410, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.15405755492358, "lm_q1q2_score": 0.08063685915437716}}
{"text": "![Callysto.ca Banner](https://github.com/callysto/curriculum-notebooks/blob/master/callysto-notebook-banner-top.jpg?raw=true)\n\n<a href=\"https://hub.callysto.ca/jupyter/hub/user-redirect/git-pull?repo=https%3A%2F%2Fgithub.com%2Fcallysto%2Fcurriculum-notebooks&branch=master&subPath=Mathematics/DataRepresentation/data-representation.ipynb&depth=1\" target=\"_parent\"><img src=\"https://raw.githubusercontent.com/callysto/curriculum-notebooks/master/open-in-callysto-button.svg?sanitize=true\" width=\"123\" height=\"24\" alt=\"Open in Callysto\"/></a>\n\nfrom IPython.display import HTML\nhide_me = ''\nHTML('''<script>\ncode_show=true; \nfunction code_toggle() {\n  if (code_show) {\n    $('div.input').each(function(id) {\n      el = $(this).find('.cm-variable:first');\n      if (id == 0 || el.text() == 'hide_me') {\n        $(this).hide();\n      }\n    });\n    $('div.output_prompt').css('opacity', 0);\n  } else {\n    $('div.input').each(function(id) {\n      $(this).show();\n    });\n    $('div.output_prompt').css('opacity', 1);\n  }\n  code_show = !code_show\n} \n$( document ).ready(code_toggle);\n</script>\n<form action=\"javascript:code_toggle()\"><input style=\"opacity:1\" type=\"submit\" value=\"Click here to toggle on/off the raw code.\"></form>''')\n\nhide_me\n\nfrom ipywidgets import interact\nimport ipywidgets as widgets\nimport IPython\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport math\n\nimport plotly as py\nimport plotly.graph_objs as go\n\nimport pylab\n\nfrom IPython.display import Image, HTML, YouTubeVideo\n\n# Data Representation in Graphs\n\n### Grade 8 curriculum\n\nData plays an ever-increasing role in our lives. Like it or not, we are faced with numerical information every day, and we use it to make decisions. Should I be glad that 9 out of 10 dentists recommend my toothpaste? What about the 10th? A new study says that going for a run at 5 a.m. every morning reduces my risk of catching some terrible disease by 15%. Is it worth getting out of bed?\n\nIt's often hard to find meaning in data if it's just a bunch of numbers on a page, so we make that easier by using graphs. Graphs take data and turn them into pictures—bars, lines, circles, and more. But not all graphs are created equal; some do their jobs better than others. A good graph is a perfect tool for understanding a problem. A bad graph can be confusing, or in some cases, intentionally misleading.\n\nGraphs are used every day by news media, politicians, and scientists to convey information. Some use them well; some do not. In this notebook, we'll explore good and bad examples of graphs. By working through the examples and exercises in this notebook, you'll learn:\n\n- how to decide which type of graph is best for a given set of data;\n- how to identify flawed or misleading graphs;\n- how some of those flaws can be corrected; and\n- most importantly, how to read a graph and apply its meaning to your everyday life.\n\n\n*Many of the examples of bad graphs you'll find below are from the media (and one source in particular). This notebook isn't trying to criticize these sources. They just happen to have given us a lot of examples to choose from.*\n\n## What makes a good graph?\n\nFirst and most importantly, a graph should allow a reader, at a glance, to understand the information it's meant to convey. A good graph is like a good movie scene; if it's set up well, you can tell exactly what you're supposed to know. Some basic parts of a successful graph are:\n\n1. A title\n2. Proper labels\n3. Axes that start at zero (if numerical)\n4. Percentages that add to 100%\n5. Easy to read\n6. Use of colours, *as long as they are meaningful* and not just for show\n\n*By the way: **axes** (ACK-sees) are the reference lines on a graph. They're where you find the names of the categories (usually at the bottom) and the number scale (usually on the left).  One of these lines is called an **axis** (ACK-sis).*\n\nFor a quick overview of different types of graphs and simple examples, you might find this \n[Math Is Fun](https://www.mathsisfun.com/data/pictographs.html) article useful. We'll look at some of these kinds of graphs below. You'll notice many of them are eye-catching, and they also convey information really well.\n\nOne of the places you'll find a lot of graphs is in political coverage. The media (and many of their readers/viewers) love a good \"horse race\". For example, this [CBC federal poll tracking article](http://www.cbc.ca/news/politics/poll-tracker-federal-poll-averages-and-seat-projections-1.4171977) uses almost every type of graph you'll find in this notebook.\n\nWe'll also explore how a graph can be used to [mislead someone](http://teachersinstitute.yale.edu/curriculum/units/2008/6/08.06.06.x.html). We hope this notebook will help you learn how to avoid using misleading graphs, as well as how to avoid being misled yourself.\n\nThere's even a [wall of shame](http://bcuchta.com/wall_of_shame/) with some of the worst graphs and charts!\n\n## Let's look at bar graphs\n\n### What is a bar graph?\n\nA bar graph is a graph where data is separated into categories, and those categories are shown as bars with different heights. It's a very useful graph, but it can also easily be misleading.\n\n![picture](./images/bar-graph-fruit.svg)\n\nfrom [Math is Fun](https://mathsisfun.com/data/images/bar-graph-fruit.svg)\n\n### When are bar graphs good to use?\n\nBar graphs can be used in many ways, but they usually show one piece of information collected from many groups or categories. For example, they might show the number of hours worked by people in different age groups, or how many grey shirts each girl in a class owns.\n\n### What are some ways to misuse bar graphs?\n\n1. **Make the scale on the graph start above zero.** This makes small differences between bars look much bigger than they really are.\n2. **Change the width of the bars to make one category look more important.** This gives one bar more area, which looks like more data.\n3. **Remove the space between the bars** (that's a **histogram**). Histograms are used for a different kind of data set, and so they are read in a different way.\n\nHere's an example of a poorly made bar graph.  It shows the total welfare (support money) received by people in the US from 2009 to 2011.  Each year is divided into 4 three-month pieces called **quarters**.\n\n![picture](./images/fnc-an-20120809-welfarechart.jpg)\n\nfrom [MediaMatters](https://www.mediamatters.org/fox-news/today-dishonest-fox-charts-government-aid-edition)\n\nWhat makes this a bad bar graph?\n1. Their scale starts at 94 million insead of 0.\n2. The bars are in 3D, making their values harder to read.\n3. Their y-axis has 8 labels, but there are 10 levels on the graph (including the top and bottom).\n\nWhoever made this graph probably wanted the viewer to think welfare in the US is rising faster than it really is.  Now, let's ask ourselves:\n\n- What can we change to make this a good graph?\n- How does it look after we make these changes?\n- Why might the original creators not want to use our new graph?\n\nOne way we can improve this graph is by changing where its scale starts.  Play with the slider below to see how the graph looks with different scales.\n\n*Slide the slider below to change the starting point of the $y$-axis. The initial position corresponds to the graph in the image above. As you move the slider to the left, the starting point for the $y$-axis is reduced to zero.*\n\n*Warning: This graph is slow to respond, please be patient with it.*\n\nhide_me\n\ncolumns = ['09-Q1', '09-Q2', '09-Q3', '09-Q4', '10-Q1', '10-Q2','10-Q3', '10-Q4', '11-Q1', '11-Q2']\n#fig, ax = plt.subplots()\ndef plot(yaxis=94):\n    y = [97, 98, 99, 101, 104, 105, 106, 107, 107.5, 108]\n    x = np.arange(len(y))\n    fig, ax = plt.subplots(figsize=(10,4))\n    ax.bar(x, y, width=0.5)\n    ax.set_xticks(x)\n    ax.set_xticklabels(columns)\n    ax.set_ylim((yaxis,110))\n    ax.set_title(\"Federal Welfare Received in the US\")\n    \ninteract(plot, yaxis=(0,90), continuous_update = True, wait = False)\n#plt.show()\n\n## Let's look at pictographs\n\n### What is a pictograph?\n\nA pictograph is a way to show data using images, where each image represents a certain number of things that are being measured. They look a lot like bar graphs and they can be horizontal or vertical too.\n\n![picture](./images/pictograph-tennis.svg)\n\nfrom [Math is Fun](https://www.mathsisfun.com/data/images/pictograph-tennis.svg)\n\n### Why do people like to use pictographs?\n\nThe main reason is because the pictures offer something for readers to connect with other than just a row of coloured bars.\n\nAlso, pictographs often work best to show data with small numbers. If everything can be easily expressed with a simple scale like the one above, then a pictograph might be the right choice to represent the data.\n\n### When are pictographs not a good choice?\n\nIn the example above, what if Sam played 46 games instead of 45? This pictogram counts games in steps of 5, so numbers in between these steps might be hard or impossible to show.\n\nA reader might also make a connection with a pictograph that wasn't intended.  Let's show this with an example.\n\nOn Halloween, Shayna and Michael went trick-or-treating.  Shayna got 18 pieces of candy, and Michael got 36.  Their totals are shown in this pictograph:\n\n![picture](./images/halloween-candy-collected.jpg)\n\nfrom [teachersinstitute.yale.edu](http://teachersinstitute.yale.edu/curriculum/units/2008/6/08.06.06.x.html)\n\nAt first, is looks like a fine way to show how much candy each child got. The heights of the candy corn pieces are being used to mark the two amounts.  But as a viewer, we don't see just the height—we also see the width. Not only is the second candy corn twice as high, it's also twice as wide, giving it four times the area as the first candy corn.  This makes it *look like* Michael got 4 times as much candy as Shayna, even though he only got twice as much.\n\nClick the \"Display\" button below to show a better, more accurate way to represent the same data:\n\nhide_me\n\npic = Image('images/CandyCornGraph.png')\nclicker = widgets.Checkbox(value=False, description='Display', disabled=False)\n\ndef checking(a):\n    if clicker.value == True:\n        IPython.display.display(pic)\n    else:\n        IPython.display.clear_output()\n        IPython.display.display(clicker)\n\nIPython.display.display(clicker)\nclicker.observe(checking, 'value')\n\n## Let's look at line graphs\n\n### What is a line graph?\n\nA line graph is a way to show how the measurement of one value responds to changes in another, like how something may change over time. In fact, time is one of the most common variables with a line graph.\n\n![picture](./images/line-graph-example.svg)\n\nfrom [Math is Fun](https://www.mathsisfun.com/data/images/line-graph-example.svg)\n\n### Why are line graphs useful?\n\nThey show a moving trend with a line that's easy to follow, instead of just dots on a graph. They work best when the trend involves the change of one variable (jobs, temperature, debt) with respect to another (usually time).\n\nIn some cases it can also be useful to plot multiple lines on one graph, usually with different colours to help tell them apart. For example, one might plot polling results for different political parties over time, as with this graph from the CBC:\n\n![federal polling averages](./images/poll-averages.jpg)\n\nfrom [cbc.ca](http://www.cbc.ca/polopoly_fs/1.3265490!/fileImage/httpImage/image.jpg)\n\n\n### How can line graphs go wrong?\n\nA common error with line graphs is unlabelled axes. A graph might show a line that slopes upwards, but without labels, we wouldn't know what is growing or how fast. Also, line graphs can trick us into thinking a trend is linear by spacing out the ticks unevenly on one axis, so that the data points neatly line up. Like this example:\n\n![Picture](./images/job-loss-by-quarter.png)\n\nfrom [Online Stat Book](http://onlinestatbook.com/2/graphing_distributions/graphics/graph2.png)\n\nhide_me\n\nfix = widgets.SelectionSlider(options=['original', 'fixed'], value ='original', description='Slide to fix',\n    continuous_update=True, orientation='horizontal',)\n\ndef fixing(a):\n    if fix.value == 'fixed':\n        IPython.display.clear_output()\n        IPython.display.display(fix)\n        f, ax1 = plt.subplots(1,1,figsize=(10,5))\n        ax1.set_title(\"Job Loss by Quarter\")\n        ax1.set_xlabel('Months from November 07',fontsize=15)\n        ax1.set_ylabel(\"Jobs Lost in Millions\",color='b',fontsize=15)\n        x1 = [1, 10, 16, 29]\n        y1 = [7,9,13.5,15]\n        ax1.plot(x1, y1,\"bo-\")\n        plt.legend()\n        plt.show()\n    else:\n        IPython.display.clear_output()\n        IPython.display.display(fix)\n        f, ax1 = plt.subplots(1,1,figsize=(10,5))\n        ax1.set_title(\"Job Loss by Quarter\")\n        ax1.set_xlabel('Months from November 07',fontsize=15)\n        ax1.set_ylabel(\"Jobs Lost in Millions\",color='b',fontsize=15)\n        x1 = [0,7,23,29]\n        y1 = [7,9,13.5,15]\n        ax1.plot(x1, y1,\"bo-\")\n        plt.legend()\n        plt.show()\n        \nIPython.display.display(fix)        \nfix.observe(fixing, 'value')\n\nIPython.display.clear_output()\nIPython.display.display(fix)\nf, ax1 = plt.subplots(1,1,figsize=(10,5))\nax1.set_title(\"Job Loss by Quarter\")\nax1.set_xlabel('Months from November 07',fontsize=15)\nax1.set_ylabel(\"Jobs Lost in Millions\",color='b',fontsize=15)\nx1 = [0,7,23,29]\ny1 = [7,9,13.5,15]\nax1.plot(x1, y1,\"bo-\")\nplt.legend()\nplt.show()\n\n## Let's look at circle graphs\n\n### What is a circle graph?\n\nAlso known as a pie chart, a circle graph is used to show how a total is split into different groups. The whole pie represents the total, and each slice of the pie represents a different group.  Each slice gets as much of the pie as its group has of the total—the bigger the slice, the more of the total that group represents.\n\n![picture](./images/pie-chart-movies.svg)\n\nfrom [Math is Fun](https://www.mathsisfun.com/data/images/pie-chart-movies.svg)\n\n### Why are circle graphs useful?\n\nThey make it easy to compare group sizes; if there's a biggest or smallest group, that's easy to see, since group sizes are shown as pieces of a whole.\n\n### Why might people not use circle graphs?\n\nTo be displayed as a circle graph, data must be converted into percentages of the total, then into slices of a circle, which is more work than other graphs need. Plus, it's easy to mess up if the data are not converted properly (or at all). Circle graphs are also hard to draw accurately on paper, since you need a protractor to ensure your angles are correct. Some people might even say that any time a circle graph would do, a bar graph would do better, and that the pie chart below is the only acceptable one.\n\n![picture](./images/Pie-I-have-Eaten.jpg)\n\nfrom [Flowing Data](https://i1.wp.com/flowingdata.com/wp-content/uploads/2008/09/Pie-I-have-Eaten.jpg)\n\n********************\n\n### What's wrong with these graphs?\n\n![Picture](./images/unemployment-rate.jpg)\n\n[Business Insider](https://amp.businessinsider.com/images/51cb26c469beddf14c000015-750-453.jpg)\n\n![Picture](./images/candidates-pie.png)\n\n[Flowing Data](http://flowingdata.com/wp-content/uploads/yapb_cache/app15725951258947184.acq6gmp0hf4sowckg80ssc8wg.2xne1totli0w8s8k0o44cs0wc.th.png)\n\n![Picture](./images/130207SuperBowlPoll.jpg)\n\n[Flowing Data](https://i0.wp.com/flowingdata.com/wp-content/uploads/2013/03/130207SuperBowlPoll.jpg?fit=500%2C430&ssl=1)\n\n\n## What was wrong with these graphs?\n\n1. Mislabeled/Missing axes\n2. Plotted wrong\n3. Hard to read\n4. Numbers don't add to 100%\n5. Wrong data shown\n\nThe video below goes through several examples of bad/misleading graphs (some of them shown in this notebook) and why they are not good representations of the original data.\n\nhide_me\n\nYouTubeVideo('1F7gm_BG0iQ')\n\n*************\n\n## Practice Questions\n\n### Question 1\n\nA group of kids was asked **what they do first** when they get home from school. The data are shown in the table below. [Data source here](http://www.ur.umich.edu/9900/Apr03_00/7.htm)\n\n| Activity        | Percent|\n|-----------------|-----|\n|   Eat           | 27% |\n|   Personal Care | 19% |\n|   Watch TV      | 15% |\n|   Study         | 13% |\n|   Play          | 9%  |\n|   Other         | 17% |\n\nhide_me\n\nanswer = widgets.RadioButtons(options=['','circle graph', 'line graph', 'bar graph', 'pictograph'],\n                              value='', description='Answer:')\nlabels = ['Eat', 'Personal Care', 'Watch TV', 'Study', 'Play', 'Other']\ndata = [0.27, 0.19, 0.15, 0.13, 0.09, 0.17]\n\ndef display():\n    print('What would be the best graph to display this set of data?')\n    IPython.display.display(answer)\n\ndef check(a):\n    IPython.display.clear_output(wait=False)\n    display()\n    if answer.value == 'circle graph':\n        print(\"Correct! Circle graphs are used for percentages.\")\n        print(\"Let's see this data in a circle graph.\")\n        patches, texts = plt.pie(data, labels=labels)\n        plt.axis('equal')\n        plt.tight_layout()\n        plt.show()\n    else:\n        if answer.value == 'bar graph':\n            print(\"A Bar graph would work, but there's a better option. Try again.\")\n        else:\n            if answer.value == 'line graph':\n                print(\"Line graphs are good for change over time, not percentages. Try again.\")\n            else:\n                print(\"A pictograph would work if the data was in amounts instead of percentages. Try again.\")\n\ndisplay()\nanswer.observe(check, 'value')\n\n### Question 2\n\nA group of kids was asked **how much time** they spend doing different activities after school.  The data are shown in the table below. [Data source here](http://www.ur.umich.edu/9900/Apr03_00/7.htm)\n\n| Activity        | Time spent (minutes)|\n|-----------------|-----|\n|   Reading       | 30  |\n|  Chores         | 30  |\n|   Watch TV      | 100 |\n|   Study         | 60  |\n|   Play          | 74  |\n|   Sports        | 60  |\n\nhide_me\n\nanswer2 = widgets.RadioButtons(options=['','circle graph', 'line graph', 'bar graph', 'pictograph'],\n                              value='', description='Answer:')\nlabels2 = ['Reading', 'Chores', 'Watch TV', 'Study', 'Play', 'Sports']\ndata2 = [30, 30, 100, 60, 74, 60]\nx = np.arange(len(data2))\n\ndef display2():\n    print('What would be the best graph to display this set of data?')\n    IPython.display.display(answer2)\n\ndef check(a):\n    IPython.display.clear_output(wait=False)\n    display2()\n    if answer2.value == 'circle graph':\n        print(\"A circle graph is used for percentages. Try again.\")\n    else:\n        if answer2.value == 'bar graph':\n            print(\"Correct! A bar graph shows the relation between both parameters in an easy to read format.\")\n            print(\"Let's see what that looks like.\")\n            plt.bar(x, data2, width = .3)\n            plt.xticks(x, labels2)\n            plt.ylabel('Time in Minutes')\n            plt.title('Time Spent on Afterschool Activities')\n            plt.show()\n        else:\n            if answer2.value == 'line graph':\n                print(\"Line graphs are good for change over time. Try again.\")\n            else:\n                print(\"A pictograph would work, but there's a better option to be more accurate. Try again.\")\n\ndisplay2()\nanswer2.observe(check, 'value')\n\nNow that we have seen many examples of both good and bad graphs, let's look at [the worst graphs in science literature](https://www.biostat.wisc.edu/~kbroman/topten_worstgraphs/) and try to figure out why each graph is on the list.\n\n(You can click on a graph to make it bigger.  See if you can point out the flaws in these graphs on your own, then click the \"Discussion\" links to learn what's wrong with each graph and why it made it to the list!)\n\n*Even top academic institutions sometimes produce images that, while they might look impressive, do very little to help us understand the numbers involved in an issue. Try to figure out what's wrong with these\n[infographics from Princeton](http://www.princeton.edu/~ina/infographics/index.html) on your own.*\n\n## What have we learned?\n\nIn this notebook, we have learned:\n\n* Graphs are great at conveying numerical information\n* Not all types of graphs are created equal\n* Graphs can be manipulated to be misleading\n* How to identify misleading parts of graphs \n* There are steps to create truthful graphs\n\nWith this knowledge, you are able to be more informed when you see any kind of data displayed in a graph. You are also able to create truthful graphs of your own. Keep trying to identify good and bad graphs in your every day life.\n\n[![Callysto.ca License](https://github.com/callysto/curriculum-notebooks/blob/master/callysto-notebook-banner-bottom.jpg?raw=true)](https://github.com/callysto/curriculum-notebooks/blob/master/LICENSE.md)", "meta": {"hexsha": "3ec2b33745f0d083c39ad0e29c2eae94791bc2cf", "size": 20668, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/curriculum-notebooks/Mathematics/DataRepresentation/data-representation.py", "max_stars_repo_name": "BryceHaley/curriculum-jbook", "max_stars_repo_head_hexsha": "d1246799ddfe62b0cf5c389394a18c2904383437", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-18T18:19:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T18:19:40.000Z", "max_issues_repo_path": "_build/jupyter_execute/curriculum-notebooks/Mathematics/DataRepresentation/data-representation.py", "max_issues_repo_name": "callysto/curriculum-jbook", "max_issues_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/curriculum-notebooks/Mathematics/DataRepresentation/data-representation.py", "max_forks_repo_name": "callysto/curriculum-jbook", "max_forks_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.0797266515, "max_line_length": 512, "alphanum_fraction": 0.7155022257, "include": true, "reason": "import numpy", "num_tokens": 5169, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3486451353339458, "lm_q2_score": 0.2309197576365038, "lm_q1q2_score": 0.08050905015246083}}
{"text": "\"\"\"Module for compiling codegen output, and wrap the binary for use in\npython.\n\n.. note:: To use the autowrap module it must first be imported\n\n   >>> from sympy.utilities.autowrap import autowrap\n\nThis module provides a common interface for different external backends, such\nas f2py, fwrap, Cython, SWIG(?) etc. (Currently only f2py and Cython are\nimplemented) The goal is to provide access to compiled binaries of acceptable\nperformance with a one-button user interface, i.e.\n\n    >>> from sympy.abc import x,y\n    >>> expr = ((x - y)**(25)).expand()\n    >>> binary_callable = autowrap(expr)\n    >>> binary_callable(1, 2)\n    -1.0\n\nThe callable returned from autowrap() is a binary python function, not a\nSymPy object.  If it is desired to use the compiled function in symbolic\nexpressions, it is better to use binary_function() which returns a SymPy\nFunction object.  The binary callable is attached as the _imp_ attribute and\ninvoked when a numerical evaluation is requested with evalf(), or with\nlambdify().\n\n    >>> from sympy.utilities.autowrap import binary_function\n    >>> f = binary_function('f', expr)\n    >>> 2*f(x, y) + y\n    y + 2*f(x, y)\n    >>> (2*f(x, y) + y).evalf(2, subs={x: 1, y:2})\n    0.e-110\n\nThe idea is that a SymPy user will primarily be interested in working with\nmathematical expressions, and should not have to learn details about wrapping\ntools in order to evaluate expressions numerically, even if they are\ncomputationally expensive.\n\nWhen is this useful?\n\n    1) For computations on large arrays, Python iterations may be too slow,\n       and depending on the mathematical expression, it may be difficult to\n       exploit the advanced index operations provided by NumPy.\n\n    2) For *really* long expressions that will be called repeatedly, the\n       compiled binary should be significantly faster than SymPy's .evalf()\n\n    3) If you are generating code with the codegen utility in order to use\n       it in another project, the automatic python wrappers let you test the\n       binaries immediately from within SymPy.\n\n    4) To create customized ufuncs for use with numpy arrays.\n       See *ufuncify*.\n\nWhen is this module NOT the best approach?\n\n    1) If you are really concerned about speed or memory optimizations,\n       you will probably get better results by working directly with the\n       wrapper tools and the low level code.  However, the files generated\n       by this utility may provide a useful starting point and reference\n       code. Temporary files will be left intact if you supply the keyword\n       tempdir=\"path/to/files/\".\n\n    2) If the array computation can be handled easily by numpy, and you\n       don't need the binaries for another project.\n\n\"\"\"\n\nfrom __future__ import print_function, division\n\n_doctest_depends_on = { 'exe': ('f2py', 'gfortran'), 'modules': ('numpy',)}\n\nimport sys\nimport os\nimport shutil\nimport tempfile\nfrom subprocess import STDOUT, CalledProcessError\n\nfrom sympy.core.compatibility import check_output\nfrom sympy.utilities.codegen import (\n    get_code_generator, Routine, OutputArgument, InOutArgument,\n    CodeGenArgumentListError, Result\n)\nfrom sympy.utilities.lambdify import implemented_function\nfrom sympy.utilities.decorator import doctest_depends_on\nfrom sympy import C\n\n\nclass CodeWrapError(Exception):\n    pass\n\n\nclass CodeWrapper:\n    \"\"\"Base Class for code wrappers\"\"\"\n    _filename = \"wrapped_code\"\n    _module_basename = \"wrapper_module\"\n    _module_counter = 0\n\n    @property\n    def filename(self):\n        return \"%s_%s\" % (self._filename, CodeWrapper._module_counter)\n\n    @property\n    def module_name(self):\n        return \"%s_%s\" % (self._module_basename, CodeWrapper._module_counter)\n\n    def __init__(self, generator, filepath=None, flags=[], verbose=False):\n        \"\"\"\n        generator -- the code generator to use\n        \"\"\"\n        self.generator = generator\n        self.filepath = filepath\n        self.flags = flags\n        self.quiet = not verbose\n\n    @property\n    def include_header(self):\n        return bool(self.filepath)\n\n    @property\n    def include_empty(self):\n        return bool(self.filepath)\n\n    def _generate_code(self, main_routine, routines):\n        routines.append(main_routine)\n        self.generator.write(\n            routines, self.filename, True, self.include_header,\n            self.include_empty)\n\n    def wrap_code(self, routine, helpers=[]):\n\n        workdir = self.filepath or tempfile.mkdtemp(\"_sympy_compile\")\n        if not os.access(workdir, os.F_OK):\n            os.mkdir(workdir)\n        oldwork = os.getcwd()\n        os.chdir(workdir)\n        try:\n            sys.path.append(workdir)\n            self._generate_code(routine, helpers)\n            self._prepare_files(routine)\n            self._process_files(routine)\n            mod = __import__(self.module_name)\n        finally:\n            sys.path.remove(workdir)\n            CodeWrapper._module_counter += 1\n            os.chdir(oldwork)\n            if not self.filepath:\n                shutil.rmtree(workdir)\n\n        return self._get_wrapped_function(mod)\n\n    def _process_files(self, routine):\n        command = self.command\n        command.extend(self.flags)\n        try:\n            retoutput = check_output(command, stderr=STDOUT)\n        except CalledProcessError as e:\n            raise CodeWrapError(\n                \"Error while executing command: %s. Command output is:\\n%s\" % (\n                    \" \".join(command), e.output))\n        if not self.quiet:\n            print(retoutput)\n\n\nclass DummyWrapper(CodeWrapper):\n    \"\"\"Class used for testing independent of backends \"\"\"\n\n    template = \"\"\"# dummy module for testing of SymPy\ndef %(name)s():\n    return \"%(expr)s\"\n%(name)s.args = \"%(args)s\"\n%(name)s.returns = \"%(retvals)s\"\n\"\"\"\n\n    def _prepare_files(self, routine):\n        return\n\n    def _generate_code(self, routine, helpers):\n        with open('%s.py' % self.module_name, 'w') as f:\n            printed = \", \".join(\n                [str(res.expr) for res in routine.result_variables])\n            # convert OutputArguments to return value like f2py\n            inargs = filter(lambda x: not isinstance(\n                x, OutputArgument), routine.arguments)\n            retvals = []\n            for val in routine.result_variables:\n                if isinstance(val, Result):\n                    retvals.append('nameless')\n                else:\n                    retvals.append(val.result_var)\n\n            print(DummyWrapper.template % {\n                'name': routine.name,\n                'expr': printed,\n                'args': \", \".join([str(arg.name) for arg in inargs]),\n                'retvals': \", \".join([str(val) for val in retvals])\n            }, end=\"\", file=f)\n\n    def _process_files(self, routine):\n        return\n\n    @classmethod\n    def _get_wrapped_function(cls, mod):\n        return mod.autofunc\n\n\nclass CythonCodeWrapper(CodeWrapper):\n    \"\"\"Wrapper that uses Cython\"\"\"\n\n    setup_template = \"\"\"\nfrom distutils.core import setup\nfrom distutils.extension import Extension\nfrom Cython.Distutils import build_ext\n\nsetup(\n    cmdclass = {'build_ext': build_ext},\n    ext_modules = [Extension(%(args)s)]\n        )\n\"\"\"\n\n    @property\n    def command(self):\n        command = [sys.executable, \"setup.py\", \"build_ext\", \"--inplace\"]\n        return command\n\n    def _prepare_files(self, routine):\n        pyxfilename = self.module_name + '.pyx'\n        codefilename = \"%s.%s\" % (self.filename, self.generator.code_extension)\n\n        # pyx\n        with open(pyxfilename, 'w') as f:\n            self.dump_pyx([routine], f, self.filename,\n                self.include_header, self.include_empty)\n\n        # setup.py\n        ext_args = [repr(self.module_name), repr([pyxfilename, codefilename])]\n        with open('setup.py', 'w') as f:\n            print(CythonCodeWrapper.setup_template % {\n                'args': \", \".join(ext_args)}, file=f)\n\n    @classmethod\n    def _get_wrapped_function(cls, mod):\n        return mod.autofunc_c\n\n    def dump_pyx(self, routines, f, prefix, header=True, empty=True):\n        \"\"\"Write a Cython file with python wrappers\n\n           This file contains all the definitions of the routines in c code and\n           refers to the header file.\n\n           :Arguments:\n\n           routines\n                List of Routine instances\n           f\n                File-like object to write the file to\n           prefix\n                The filename prefix, used to refer to the proper header file.\n                Only the basename of the prefix is used.\n           empty\n                Optional. When True, empty lines are included to structure the\n                source files. [DEFAULT=True]\n        \"\"\"\n        for routine in routines:\n            prototype = self.generator.get_prototype(routine)\n\n            # declare\n            print('cdef extern from \"%s.h\":' % prefix, file=f)\n            print('   %s' % prototype, file=f)\n            if empty:\n                print(file=f)\n\n            # wrap\n            ret, args_py = self._split_retvals_inargs(routine.arguments)\n            args_c = \", \".join([str(a.name) for a in routine.arguments])\n            print(\"def %s_c(%s):\" % (routine.name,\n                \", \".join(self._declare_arg(arg) for arg in args_py)), file=f)\n            for r in ret:\n                if not r in args_py:\n                    print(\"   cdef %s\" % self._declare_arg(r), file=f)\n            rets = \", \".join([str(r.name) for r in ret])\n            if routine.results:\n                call = '   return %s(%s)' % (routine.name, args_c)\n                if rets:\n                    print(call + ', ' + rets, file=f)\n                else:\n                    print(call, file=f)\n            else:\n                print('   %s(%s)' % (routine.name, args_c), file=f)\n                print('   return %s' % rets, file=f)\n\n            if empty:\n                print(file=f)\n    dump_pyx.extension = \"pyx\"\n\n    def _split_retvals_inargs(self, args):\n        \"\"\"Determines arguments and return values for python wrapper\"\"\"\n        py_args = []\n        py_returns = []\n        for arg in args:\n            if isinstance(arg, OutputArgument):\n                py_returns.append(arg)\n            elif isinstance(arg, InOutArgument):\n                py_returns.append(arg)\n                py_args.append(arg)\n            else:\n                py_args.append(arg)\n        return py_returns, py_args\n\n    def _declare_arg(self, arg):\n        t = arg.get_datatype('c')\n        if arg.dimensions:\n            return \"%s *%s\" % (t, str(arg.name))\n        else:\n            return \"%s %s\" % (t, str(arg.name))\n\n\nclass F2PyCodeWrapper(CodeWrapper):\n    \"\"\"Wrapper that uses f2py\"\"\"\n\n    @property\n    def command(self):\n        filename = self.filename + '.' + self.generator.code_extension\n        command = [\"f2py\", \"-m\", self.module_name, \"-c\", filename]\n        return command\n\n    def _prepare_files(self, routine):\n        pass\n\n    @classmethod\n    def _get_wrapped_function(cls, mod):\n        return mod.autofunc\n\n\ndef _get_code_wrapper_class(backend):\n    wrappers = { 'F2PY': F2PyCodeWrapper, 'CYTHON': CythonCodeWrapper,\n        'DUMMY': DummyWrapper}\n    return wrappers[backend.upper()]\n\n\n@doctest_depends_on(exe=('f2py', 'gfortran'), modules=('numpy',))\ndef autowrap(\n    expr, language='F95', backend='f2py', tempdir=None, args=None, flags=[],\n        verbose=False, helpers=[]):\n    \"\"\"Generates python callable binaries based on the math expression.\n\n    expr\n        The SymPy expression that should be wrapped as a binary routine\n\n    :Optional arguments:\n\n    language\n        The programming language to use, currently 'C' or 'F95'\n    backend\n        The wrapper backend to use, currently f2py or Cython\n    tempdir\n        Path to directory for temporary files.  If this argument is supplied,\n        the generated code and the wrapper input files are left intact in the\n        specified path.\n    args\n        Sequence of the formal parameters of the generated code, if ommited the\n        function signature is determined by the code generator.\n    flags\n        Additional option flags that will be passed to the backend\n    verbose\n        If True, autowrap will not mute the command line backends.  This can be\n        helpful for debugging.\n    helpers\n        Used to define auxillary expressions needed for the main expr.  If the\n        main expression need to do call a specialized function it should be put\n        in the ``helpers`` list.  Autowrap will then make sure that the compiled\n        main expression can link to the helper routine.  Items should be tuples\n        with (<funtion_name>, <sympy_expression>, <arguments>).  It is\n        mandatory to supply an argument sequence to helper routines.\n\n    >>> from sympy.abc import x, y, z\n    >>> from sympy.utilities.autowrap import autowrap\n    >>> expr = ((x - y + z)**(13)).expand()\n    >>> binary_func = autowrap(expr)\n    >>> binary_func(1, 4, 2)\n    -1.0\n\n    \"\"\"\n\n    code_generator = get_code_generator(language, \"autowrap\")\n    CodeWrapperClass = _get_code_wrapper_class(backend)\n    code_wrapper = CodeWrapperClass(code_generator, tempdir, flags, verbose)\n    try:\n        routine = Routine('autofunc', expr, args)\n    except CodeGenArgumentListError as e:\n        # if all missing arguments are for pure output, we simply attach them\n        # at the end and try again, because the wrappers will silently convert\n        # them to return values anyway.\n        new_args = []\n        for missing in e.missing_args:\n            if not isinstance(missing, OutputArgument):\n                raise\n            new_args.append(missing.name)\n        routine = Routine('autofunc', expr, args + new_args)\n\n    helps = []\n    for name, expr, args in helpers:\n        helps.append(Routine(name, expr, args))\n\n    return code_wrapper.wrap_code(routine, helpers=helps)\n\n\n@doctest_depends_on (exe=('f2py', 'gfortran'), modules=('numpy',))\ndef binary_function(symfunc, expr, **kwargs):\n    \"\"\"Returns a sympy function with expr as binary implementation\n\n    This is a convenience function that automates the steps needed to\n    autowrap the SymPy expression and attaching it to a Function object\n    with implemented_function().\n\n    >>> from sympy.abc import x, y\n    >>> from sympy.utilities.autowrap import binary_function\n    >>> expr = ((x - y)**(25)).expand()\n    >>> f = binary_function('f', expr)\n    >>> type(f)\n    <class 'sympy.core.function.UndefinedFunction'>\n    >>> 2*f(x, y)\n    2*f(x, y)\n    >>> f(x, y).evalf(2, subs={x: 1, y: 2})\n    -1.0\n    \"\"\"\n    binary = autowrap(expr, **kwargs)\n    return implemented_function(symfunc, binary)\n\n@doctest_depends_on (exe=('f2py', 'gfortran'), modules=('numpy',))\ndef ufuncify(args, expr, **kwargs):\n    \"\"\"\n    Generates a binary ufunc-like lambda function for numpy arrays\n\n    ``args``\n        Either a Symbol or a tuple of symbols. Specifies the argument sequence\n        for the ufunc-like function.\n\n    ``expr``\n        A SymPy expression that defines the element wise operation\n\n    ``kwargs``\n        Optional keyword arguments are forwarded to autowrap().\n\n    The returned function can only act on one array at a time, as only the\n    first argument accept arrays as input.\n\n    .. Note:: a *proper* numpy ufunc is required to support broadcasting, type\n       casting and more.  The function returned here, may not qualify for\n       numpy's definition of a ufunc.  That why we use the term ufunc-like.\n\n    References\n    ==========\n    [1] http://docs.scipy.org/doc/numpy/reference/ufuncs.html\n\n    Examples\n    ========\n\n    >>> from sympy.utilities.autowrap import ufuncify\n    >>> from sympy.abc import x, y\n    >>> import numpy as np\n    >>> f = ufuncify([x, y], y + x**2)\n    >>> f([1, 2, 3], 2)\n    [ 3.  6.  11.]\n    >>> a = f(np.arange(5), 3)\n    >>> isinstance(a, np.ndarray)\n    True\n    >>> print a\n    [ 3. 4. 7. 12. 19.]\n\n    \"\"\"\n    y = C.IndexedBase(C.Dummy('y'))\n    x = C.IndexedBase(C.Dummy('x'))\n    m = C.Dummy('m', integer=True)\n    i = C.Dummy('i', integer=True)\n    i = C.Idx(i, m)\n    l = C.Lambda(args, expr)\n    f = implemented_function('f', l)\n\n    if isinstance(args, C.Symbol):\n        args = [args]\n    else:\n        args = list(args)\n\n    # first argument accepts an array\n    args[0] = x[i]\n    return autowrap(C.Equality(y[i], f(*args)), **kwargs)\n", "meta": {"hexsha": "6a47099c356afd3593e1d5d364c0b970357577ec", "size": 16352, "ext": "py", "lang": "Python", "max_stars_repo_path": "sympy/utilities/autowrap.py", "max_stars_repo_name": "lidavidm/sympy", "max_stars_repo_head_hexsha": "971aa94ee6d0774eacfb4aed6965195c4a59e104", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-03-12T02:52:16.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-12T02:52:16.000Z", "max_issues_repo_path": "sympy/utilities/autowrap.py", "max_issues_repo_name": "lidavidm/sympy", "max_issues_repo_head_hexsha": "971aa94ee6d0774eacfb4aed6965195c4a59e104", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sympy/utilities/autowrap.py", "max_forks_repo_name": "lidavidm/sympy", "max_forks_repo_head_hexsha": "971aa94ee6d0774eacfb4aed6965195c4a59e104", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.5770020534, "max_line_length": 80, "alphanum_fraction": 0.624694227, "include": true, "reason": "import numpy,from sympy", "num_tokens": 3879, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.45713673161914675, "lm_q2_score": 0.17553807362342935, "lm_q1q2_score": 0.08024490125093564}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Visualização de dados com _seaborn_\n\n# No capítulo [Plotagem e formatação de gráficos](09-plotagem-matplot.ipynb), fizemos uma breve introdução à _visualização de dados_ e aprendemos a utilizar o _matplotlib_ para realizar plotagens básicas de gráficos. Neste capítulo, exploraremos a visualização de dados utilizando o módulo _seaborn_. \n# \n# O _seaborn_ estende as potencialidades do _matplotlib_ em, praticamente, dois aspectos: i) provendo melhor estilização dos gráficos e tornando-os visualmente \"belos\"; ii) compactando funções de plotagem do _matplotlib_, de modo que plotagens robustas sejam obtidas com menos instruções de código.\n\n# Vamos começar importando as bibliotecas que utilizaremos.\n\n# In[1]:\n\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\nimport warnings\nwarnings.filterwarnings('ignore')\n\n\n# Vamos reconstruir e importar alguns *DataFrames*.\n\n# In[2]:\n\n\nserie_Idade = pd.Series({'Ana':20, 'João': 19, 'Maria': 21, 'Pedro': 22, 'Túlio': 20}, name=\"Idade\")\nserie_Peso = pd.Series({'Ana':55, 'João': 80, 'Maria': 62, 'Pedro': 67, 'Túlio': 73}, name=\"Peso\")\nserie_Altura = pd.Series({'Ana':162, 'João': 178, 'Maria': 162, 'Pedro': 165, 'Túlio': 171}, name=\"Altura\")\n\n\n# In[3]:\n\n\ndicionario_series_exemplo = {'Idade': serie_Idade, 'Peso': serie_Peso, 'Altura': serie_Altura}\n\n\n# In[4]:\n\n\ndf_dict_series = pd.DataFrame(dicionario_series_exemplo);df_dict_series\n\n\n# In[5]:\n\n\ndf_exemplo = pd.read_csv('../database/exemplo_data.csv', index_col=0)\ndf_exemplo['coluna_3'] = pd.Series([1,2,3,4,5,6,7,8,np.nan,np.nan],index=df_exemplo.index)\ndf_exemplo.index = pd.to_datetime(df_exemplo.index)\ndf_exemplo\n\n\n# In[6]:\n\n\ncovid_PB = pd.read_csv('https://superset.plataformatarget.com.br/superset/explore_json/?form_data=%7B%22slice_id%22%3A1550%7D&csv=true', \n                             sep=',', index_col=0)\ncovid_PB.head()\n\n\n# In[7]:\n\n\ncovid_BR = pd.read_excel('../database/HIST_PAINEL_COVIDBR_25jul2020.xlsx')\ncovid_BR.head()\n\n\n# ## Gráficos de Linha e de Dispersão\n# \n# Através da função `relplot`, podemos alterar o valor do parâmetro `kind` para\n# obter gráficos do linha, com `kind = 'line'`, ou gráficos de dispersão, com `kind  = 'scatter'`. De modo alternativo, poderíamos também utilizar as funções `lineplot` e `scatterplot`. Entretanto, com `relplot`, diversos elementos de construção de figura existentes no *matplotlib* já são pré-configurados no _seaborn_. Isto é chamado no *seaborn* de *figure-level plot*.\n\n# Inicialmente, vejamos como a função `lineplot` se comporta como qualquer outra do `matplotlib.pyplot`.\n\n# In[8]:\n\n\nfig, ax = plt.subplots()\nax = sns.lineplot(x=\"index\", y=\"coluna_1\", data=df_exemplo.reset_index(), label = 'Coluna 1')\nax = sns.lineplot(x=\"index\", y=\"coluna_2\", data=df_exemplo.reset_index(), label = 'Coluna 2')\nax = sns.lineplot(x=\"index\", y=\"coluna_3\", data=df_exemplo.reset_index(), label = 'Coluna 3')\nax.set_xlabel('Data')\nax.set_ylabel('Valor')\nfig.autofmt_xdate() # auto-formata xticks tipo \"data\"\n\n\n# Para utilizar a função `relplot`, precisaremos reorganizar o banco de dados de modo que haja apenas uma coluna de valores no eixo _y_ (`Valor`) e uma coluna com um identificador de cor/tonalidade (`Coluna`).\n\n# In[9]:\n\n\n# reorganiza para 'Coluna 1'\ndf_exemplo_px = pd.DataFrame(df_exemplo['coluna_1']).rename({'coluna_1':'Valor'}, axis=1)\ndf_exemplo_px['Coluna'] = 'Coluna 1' \n\n# concatena 'Coluna 2'\ndf_exemplo_px_temp = pd.DataFrame(df_exemplo['coluna_2']).rename({'coluna_2':'Valor'}, axis=1)\ndf_exemplo_px_temp['Coluna'] = 'Coluna 2'\ndf_exemplo_px = pd.concat([df_exemplo_px, df_exemplo_px_temp])\n\n# concatena 'Coluna 3'\ndf_exemplo_px_temp = pd.DataFrame(df_exemplo['coluna_3']).rename({'coluna_3':'Valor'}, axis=1)\ndf_exemplo_px_temp['Coluna'] = 'Coluna 3'\ndf_exemplo_px = pd.concat([df_exemplo_px, df_exemplo_px_temp])\n\ndf_exemplo_px.head()\n\n\n# In[10]:\n\n\n# 'hue' atribui as tonalidades de cor com base no identificador \np = sns.relplot(x = 'index', y='Valor', hue = 'Coluna', data=df_exemplo_px.reset_index().dropna(), kind='line')\np.fig.autofmt_xdate()\np.ax.set_xlabel('Data')\np.fig.set_size_inches(8,4) # largura, altura\n\n\n# Vamos agora plotar o gráfico de óbitos por COVID-19 na Paraíba juntamente com a média aritmética móvel de 7 dias e com a média geométrica móvel de 7 dias.\n# \n# Utilizaremos o método `rolling` de uma *Series* ou *DataFrame* do *pandas*. Este método cria janelas móveis onde podemos aplicar uma função agregadora (tal como média ou média geométrica).\n\n# Comentários: \n# \n# - A média aritmética tem a desvantagem de linearizar o efeito do crescimento ou decrescimento do número de óbitos, onde sabemos que o efeito é exponencial.\n# - A média geométrica móvel tem a desvantagem de se anular se o número de óbitos em algum dos dias da janela for zero.\n# - Em geral, as duas médias ficam muito próximas.\n\n# In[11]:\n\n\n# função que calcula a média geométrica\nfrom scipy.stats import gmean \n\n# série\ncovid_PB_obitos = covid_PB.obitosNovos\ncovid_PB_obitos = covid_PB_obitos.sort_index()\ncovid_PB_obitos.name = 'Óbitos'\n\n# dataframe\ncovid_PB_obitos_df = pd.DataFrame(covid_PB_obitos)\ncovid_PB_obitos_df['Tipo'] = 'Valor nominal'\n\n# média aritmética móvel\ncovid_PB_obitos_df_temp = pd.DataFrame(covid_PB_obitos.rolling(7).mean().dropna())\ncovid_PB_obitos_df_temp['Tipo'] = 'MM:arit - 7d'\ncovid_PB_obitos_df = pd.concat([covid_PB_obitos_df, covid_PB_obitos_df_temp])\n\n# média geométrica móvel\ncovid_PB_obitos_df_temp = pd.DataFrame(covid_PB_obitos.rolling(7).aggregate(gmean).dropna())\ncovid_PB_obitos_df_temp['Tipo'] = 'MM:geom - 7d'\ncovid_PB_obitos_df = pd.concat([covid_PB_obitos_df, covid_PB_obitos_df_temp])\n\ncovid_PB_obitos_df.index = pd.to_datetime(covid_PB_obitos_df.index)\n\ncovid_PB_obitos_df.tail()\n\n\n# In[12]:\n\n\np = sns.relplot(x = 'data', y='Óbitos', \n                hue = 'Tipo', \n                data=covid_PB_obitos_df.reset_index(), \n                kind='line')\np.fig.autofmt_xdate()\np.ax.set_xlabel(''); \np.fig.set_size_inches(8,4)\n\n\n# Vamos agora construir um gráfico de dispersão com o _DataFrame_ `df_exemplo_px`.\n\n# In[13]:\n\n\n# 'scatter' é padrão\np = sns.relplot(x = 'index', y='Valor', \n                hue = 'Coluna', \n                data=df_exemplo_px.reset_index().dropna())\np.fig.autofmt_xdate()\np.ax.set_xlabel(''); \np.fig.set_size_inches(8,4)\n\n\n# Vamos forçar os limites de datas a ficarem dentro do mínimo (menos um dia) e do máximo (mais um dia):\n\n# In[14]:\n\n\np = sns.relplot(x = 'index', y='Valor', \n                      hue = 'Coluna', \n                      data=df_exemplo_px.reset_index().dropna())\n\n# offset de data\np.ax.set_xlim((df_exemplo_px.reset_index()['index'].min()\n               - pd.DateOffset(days=1)),\n              (df_exemplo_px.reset_index()['index'].max()\n               + pd.DateOffset(days=1)))\n\np.fig.autofmt_xdate()\np.ax.set_xlabel(''); \np.fig.set_size_inches(8,4)\n\n\n# In[15]:\n\n\n# especifica cores e tamanhos\np = sns.relplot(x = 'index', y='coluna_1', \n                hue = 'coluna_2', \n                size = 'coluna_3', \n                data=df_exemplo.reset_index().dropna())\n\np.ax.set_xlim((df_exemplo.reset_index()['index'].min()\n               - pd.DateOffset(days=1)), \n              (df_exemplo.reset_index()['index'].max()\n               + pd.DateOffset(days=1)))\n\np.fig.autofmt_xdate()\np.ax.set_xlabel('')\np.fig.set_size_inches(8,4)\n\n\n# In[16]:\n\n\ncovid_PB_casos_obitos = covid_PB[['obitosNovos', 'casosNovos']].sort_index()\ncovid_PB_casos_obitos.index = pd.to_datetime(covid_PB_casos_obitos.index)\n\n# cor: óbitos novos\np = sns.relplot(x = 'data', y = 'casosNovos', \n                hue = 'obitosNovos', \n                data=covid_PB_casos_obitos.reset_index())\n\np.ax.set_xlim((covid_PB_casos_obitos.reset_index()['data'].min()\n               - pd.DateOffset(days=5)),\n              (covid_PB_casos_obitos.reset_index()['data'].max()\n               + pd.DateOffset(days=5)))\n\np.fig.autofmt_xdate()\np.ax.set_xlabel('')\np.ax.set_ylabel('Casos COVID-19 - PB')\np.ax.set_title('Casos e Óbitos de COVID-19 na Paraíba')\np.fig.set_size_inches(8,4)\n\n\n# ## Gráficos de dispersão em dados categóricos\n# \n# Quando há muitos valores repetidos em uma variável, os gráficos de dispersão podem não ilustrar efetivamente o comportamento dos dados. Neste caso, é interessante que o gráfico considere a repetição dos valores dentro de uma mesma categoria.\n\n# Comentários:\n# \n# - Isto acontece quando o eixo horizontal contém variáveis categóricas e, assim, tem-se repetição de valores dentro de uma mesma categoria.\n\n# Para gráficos deste tipo, utilizaremos os dados de óbitos por COVID-19 no Brasil. Agruparemos o número de óbitos por dia da semana.\n\n# In[17]:\n\n\ncovid_BR_obitos = covid_BR.query('regiao == \"Brasil\"')[['obitosNovos','data']]\n\ncovid_BR_obitos.data = pd.to_datetime(covid_BR_obitos.data)\n\ncovid_BR_obitos['Dia'] = covid_BR_obitos.data.dt.weekday.map(\n    {0:'Segunda-Feira',\n     1:'Terça-Feira',\n     2:'Quarta-Feira',\n     3:'Quinta-Feira',\n     4:'Sexta-Feira',\n     5:'Sábado',\n     6:'Domingo'})\n\ncovid_BR_obitos = covid_BR_obitos.set_index('data')\ncovid_BR_obitos\n\n\n# Se quisermos determinar a ordem do eixo _x_, `relplot` não é a função ideal. Além disso, devido à sobreposição dos dados, ela definitivamente não é a ideal para variáveis categóricas. Vejamos:\n\n# In[18]:\n\n\np = sns.relplot(x='Dia', y='obitosNovos', data=covid_BR_obitos)\np.ax.set_xlabel(''); \np.fig.set_size_inches(8,4)\n\n\n# ## O gráfico *stripplot*\n# \n# O *stripplot* é um gráfico de dispersão onde a cada observação é colocado um deslocamento aleatório para evitar a sobreposição e fornecer uma ideia mais precisa da quantidade de dados.\n# \n# Vamos construir o *stripplot* através da função `catplot`. O *stripplot* é o gráfico padrão do `catplot` (tem o argumento `kind = 'strip'`).\n# \n# Podemos determinar a ordem das variáveis categóricas com o argumento *order*.\n\n# In[19]:\n\n\np = sns.catplot(x='Dia', y='obitosNovos', \n                data=covid_BR_obitos, order = \n                ['Segunda-Feira', 'Terça-Feira',\n                 'Quarta-Feira', 'Quinta-Feira',\n                 'Sexta-Feira', 'Sábado', 'Domingo'])\n\np.ax.set_xlabel('');\np.fig.set_size_inches(8,4)\n\n\n# Se colocarmos `jitter=False`, obteremos o gráfico de dispersão usual (com o detalhe de que podemos definir a ordem dos rótulos do eixo *x*).\n\n# In[20]:\n\n\np = sns.catplot(x='Dia', y='obitosNovos', \n                jitter = False,\n                data=covid_BR_obitos,\n                order = ['Segunda-Feira', 'Terça-Feira',\n                         'Quarta-Feira', 'Quinta-Feira',\n                         'Sexta-Feira', 'Sábado', 'Domingo'])\n\np.ax.set_xlabel(''); \np.fig.set_size_inches(8,4)\n\n\n# ## O gráfico *swarmplot*\n# \n# O *swarmplot* é um gráfico de dispersão onde, diferentemente do *stripplot*, nenhum dado pode ficar sobreposto. Desta forma, também fornece uma ideia mais precisa da quantidade de dados.\n# \n# Construiremos o *swarmplot* através da função `catplot` com o argumento `kind = 'swarm'`. Como o *swarmplot* também é um tipo do `catplot`, podemos determinar a ordem das variáveis categóricas com o argumento `order`.\n\n# In[21]:\n\n\np = sns.catplot(x='Dia', y='obitosNovos',\n                kind = 'swarm',\n                data=covid_BR_obitos, \n                order = ['Segunda-Feira', 'Terça-Feira',\n                         'Quarta-Feira', 'Quinta-Feira',\n                         'Sexta-Feira', 'Sábado', 'Domingo'])\n\np.ax.set_xlabel('');\np.fig.set_size_inches(8,4)\n\n\n# ## Gráficos de Barras e Colunas\n# \n# Para criar gráficos de barras e colunas com o *seaborn* utilizaremos a função `catplot` com o argumento `kind=bar`. Se a variável categórica estiver no eixo *x*, o gráfico será de coluna; se a variável categórica estiver no eixo *y*, o gráfico será de barra.\n\n# In[22]:\n\n\ncovid_Regioes = covid_BR[['regiao','obitosNovos']].groupby('regiao').sum().query('regiao != \"Brasil\"')/2\n\np = sns.catplot(x='regiao', y='obitosNovos',\n                kind = 'bar',data=covid_Regioes.reset_index())\n\np.ax.set_xlabel('');\np.fig.set_size_inches(8,4)\n\n\n# In[23]:\n\n\ncovid_Regioes = covid_BR[['regiao','obitosNovos']].groupby('regiao').sum().query('regiao != \"Brasil\"')/2\n\np = sns.catplot(x='obitosNovos', y='regiao',\n                kind = 'bar',data=covid_Regioes.reset_index())\n\np.ax.set_xlabel('');\np.fig.set_size_inches(8,4)\n\n\n# In[24]:\n\n\ndf_dict_series_sns = pd.DataFrame(df_dict_series.Idade).rename({'Idade':'Valor'}, axis=1)\ndf_dict_series_sns['Dado'] = 'Idade'\n\ndf_dict_series_sns_temp = pd.DataFrame(df_dict_series.Altura).rename({'Altura':'Valor'}, axis=1)\ndf_dict_series_sns_temp['Dado'] = 'Altura'\ndf_dict_series_sns = pd.concat([df_dict_series_sns, df_dict_series_sns_temp])\n\ndf_dict_series_sns_temp = pd.DataFrame(df_dict_series.Peso).rename({'Peso':'Valor'}, axis=1)\ndf_dict_series_sns_temp['Dado'] = 'Peso'\ndf_dict_series_sns = pd.concat([df_dict_series_sns, df_dict_series_sns_temp])\n\ndf_dict_series_sns\n\n\n# In[25]:\n\n\np = sns.catplot(x='index', y='Valor', \n                hue='Dado',\n                data = df_dict_series_sns.reset_index(),\n                kind='bar')\n\np.ax.set_xlabel(''); \np.fig.set_size_inches(8,4)\n\n\n# ## _Box Plot_ e plots alternativos\n# \n# Tanto o *BoxPlot* quanto os plots alternativos que apresentaremos aqui (*violinplot* e *boxenplot*) fazem parte do `catplot`. Para construir um \n# \n# - *Box Plot* utiliza-se o argumento `kind='box'`;\n# - *Violin Plot* utiliza-se o argumento `kind='violin'`;\n# - *Boxen Plot* (ou *letter-value plot*) utiliza-se o argumento `kind='boxen'`.\n# \n# ```{note}\n# O *boxenplot* foi criado por Hadley Wickham (criador do *ggplot2* e da maioria dos pacotes do *tidyverse* do *R*) e colaboradores e é uma generalização do *BoxPlot* que apresenta mais quantis. Foi introduzido como [letter-value plots](https://vita.had.co.nz/papers/letter-value-plot.html). O *violinplot* recebe este nome, pois seu gráfico assemelha-se a um violino.\n# ```\n\n# In[26]:\n\n\np = sns.catplot(x='Dia', y='obitosNovos',\n                kind = 'box',\n                data=covid_BR_obitos,\n                order = ['Segunda-Feira', 'Terça-Feira',\n                         'Quarta-Feira', 'Quinta-Feira',\n                         'Sexta-Feira', 'Sábado', 'Domingo'])\n\np.ax.set_xlabel('');\np.fig.set_size_inches(8,4)\n\n\n# In[27]:\n\n\ncovid_regioes_diarios_px = covid_BR.set_index(\n    'data').query('regiao != \"Brasil\"')[['obitosNovos', 'regiao']].reset_index().rename(\n    {'obitosNovos':'Óbitos','regiao':'Região','data':'Data'},axis=1)\n\ncovid_regioes_diarios_px = covid_regioes_diarios_px.groupby(['Região','Data']).sum()/2\ncovid_regioes_diarios_px = covid_regioes_diarios_px.reset_index().set_index('Data')\n\ncovid_regioes_diarios_px\n\n\n# In[28]:\n\n\np = sns.catplot(x='Região', y='Óbitos',\n                kind = 'box',\n                data=covid_regioes_diarios_px)\n\np.ax.set_xlabel('');\np.fig.set_size_inches(8,4)\n\n\n# Na presença de muitos *outliers*, como é o caso do gráfico anterior, é interessante considerar uma alternativa ao *Box Plot*.\n# \n# Vamos ver agora o *Boxen Plot* (ou *letter-value plots*). Este plot considera os quantis: ..., 0.8%, 1.56%, 3.13%, 6.25%, 12.5%, 25%, 50%, 75%, 87.5%, 93.75%, 96.88%, 98.44%, 99.24%, ...\n\n# In[29]:\n\n\np = sns.catplot(x='Região', y='Óbitos',\n                kind = 'boxen',\n                data=covid_regioes_diarios_px)\n\np.ax.set_xlabel(''); \np.fig.set_size_inches(8,4)\n\n\n# Porém, em um gráfico sem muitos *outliers*, o *Boxen Plot* não difere muito do *Box Plot*.\n\n# In[30]:\n\n\np = sns.catplot(x='Dia', y='obitosNovos',\n                kind = 'boxen', \n                data=covid_BR_obitos, \n                order = ['Segunda-Feira', 'Terça-Feira',\n                         'Quarta-Feira', 'Quinta-Feira',\n                         'Sexta-Feira', 'Sábado', 'Domingo'])\np.ax.set_xlabel('');\np.fig.set_size_inches(8,4)\n\n\n# Na presença de muitos *outliers*, também é preferível um *Violin Plot* em vez de um *Box Plot*, para tornar visível o que está ocorrendo.\n\n# In[31]:\n\n\np = sns.catplot(x='Região', y='Óbitos',\n                kind = 'violin',\n                data=covid_regioes_diarios_px)\n\np.ax.set_xlabel('');\np.fig.set_size_inches(8,4)\n\n\n# Muitas vezes, é interessante sobrepor um *Violin Plot* a um *Swarm Plot* para evidenciar o comportamento da distribuição dos dados.\n\n# In[32]:\n\n\np = sns.catplot(x='Região', y='Óbitos',\n                kind = 'violin',\n                data=covid_regioes_diarios_px)\n\nsns.swarmplot(x='Região', y='Óbitos',\n              data=covid_regioes_diarios_px,\n              ax = p.ax,\n              size=4, color='k')\n\np.ax.set_xlabel('');\np.fig.set_size_inches(8,4)\n\n\n# In[33]:\n\n\np = sns.catplot(x='Dia', y='obitosNovos',\n                kind = 'violin',\n                data=covid_BR_obitos)\n\nsns.swarmplot(x='Dia', y='obitosNovos',\n              data=covid_BR_obitos,\n              ax = p.ax, size=4, color='k') \n\np.ax.set_xlabel('');\np.fig.set_size_inches(8,4)\n\n\n# ## Histogramas\n# \n# O *seaborn* constrói histogramas a partir da função `histplot`, ou da função obsoleta `distplot`. \n# \n# Incluímos um estimador de densidade baseado em núcleo Gaussiano (_Gaussian kernel_) utilizando o argumento `kde=True`.\n\n# In[34]:\n\n\nfig, ax = plt.subplots(figsize=(8,4))\n_ = sns.histplot(covid_regioes_diarios_px.query('Região==\"Nordeste\"')['Óbitos'],kde=True)\n\n\n# Para remover o estimador, selecionamos `kde=False`.\n\n# In[35]:\n\n\nfig, ax = plt.subplots(figsize=(8,4))\n_ = sns.histplot(covid_regioes_diarios_px.query('Região==\"Nordeste\"')['Óbitos'],kde=False)\n\n\n# Para plotarmos apenas o estimador de densidade sem o histograma, usamos `distplot` com a opção `hist=False`.\n\n# In[36]:\n\n\nfig, ax = plt.subplots(figsize=(8,4))\n_ = sns.distplot(covid_regioes_diarios_px.query('Região==\"Nordeste\"')['Óbitos'],hist=False)\n\n\n# É possível plotar o histograma com o estimador para qualquer série do _DataFrame_.\n\n# In[37]:\n\n\nfig, ax = plt.subplots(figsize=(8,4))\n_ = sns.histplot(df_exemplo['coluna_1'],kde=True)\n\n\n# ## Distribuição conjunta e marginal\n# \n# O histograma permite que verifiquemos a distribuição de uma ou mais variáveis, mas sem levar outras em consideração. Para plotarmos uma distribuição conjunta, bem como a distribuição individual (marginal) de cada variável, podemos utilizar a função `jointplot`.\n\n# In[38]:\n\n\n_ = sns.jointplot(x = 'coluna_1', y = 'coluna_2', data=df_exemplo, height=7)\n\n\n# O próximo exemplo usa a função `jointplot` para plotar distribuições conjuntas relativas ao número de óbitos por Covid-19 por região do Brasil durante uma certa janela temporal.\n\n# In[39]:\n\n\ncovid_regioes_diarios = pd.DataFrame()\n\nregioes = covid_BR.query('regiao != \"Brasil\"')['regiao'].drop_duplicates().array\n\nfor regiao in regioes:\n    temp_series = covid_BR.set_index('data').query('regiao == @regiao')['obitosNovos'].groupby('data').sum()/2\n    temp_series.name = 'obitos_' + regiao\n    covid_regioes_diarios = pd.concat([covid_regioes_diarios, temp_series], axis=1)\n    \ncovid_regioes_diarios.index = pd.to_datetime(covid_regioes_diarios.index)\ncovid_regioes_diarios.head()\n\n\n# In[40]:\n\n\n_ = sns.jointplot(x='obitos_Nordeste', y='obitos_Sudeste',\n                  data = covid_regioes_diarios, height=7)\n\n\n# ## Estilos e cores\n# \n# O *seaborn* disponibiliza 5 estilos pré-definidos: *darkgrid*, *whitegrid*, *dark*, *white* e *ticks*. Vejamos cada um deles.\n\n# In[41]:\n\n\nimport matplotlib.dates as mdates\nfrom matplotlib.ticker import FuncFormatter\n\n\n# In[42]:\n\n\nsns.set_style(\"darkgrid\")\np = sns.relplot(x = 'data', y='Óbitos', hue = 'Tipo', data=covid_PB_obitos_df.reset_index(), kind='line')\np.fig.autofmt_xdate()\np.ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7)) #Intervalo entre os tracinhos\np.ax.xaxis.set_major_locator(mdates.DayLocator(interval=21)) #Intervalo entre as datas\np.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y')) #Formato da data\np.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\n\n\n# In[43]:\n\n\nsns.set_style(\"whitegrid\")\np = sns.relplot(x = 'data', y='Óbitos', hue = 'Tipo', data=covid_PB_obitos_df.reset_index(), kind='line')\np.fig.autofmt_xdate()\np.ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7)) #Intervalo entre os tracinhos\np.ax.xaxis.set_major_locator(mdates.DayLocator(interval=21)) #Intervalo entre as datas\np.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y')) #Formato da data\np.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\n\n\n# In[44]:\n\n\nsns.set_style(\"dark\")\np = sns.relplot(x = 'data', y='Óbitos', hue = 'Tipo', data=covid_PB_obitos_df.reset_index(), kind='line')\np.fig.autofmt_xdate()\np.ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7)) #Intervalo entre os tracinhos\np.ax.xaxis.set_major_locator(mdates.DayLocator(interval=21)) #Intervalo entre as datas\np.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y')) #Formato da data\np.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\n\n\n# In[45]:\n\n\nsns.set_style(\"white\")\np = sns.relplot(x = 'data', y='Óbitos', hue = 'Tipo', data=covid_PB_obitos_df.reset_index(), kind='line')\np.fig.autofmt_xdate()\np.ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7)) #Intervalo entre os tracinhos\np.ax.xaxis.set_major_locator(mdates.DayLocator(interval=21)) #Intervalo entre as datas\np.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y')) #Formato da data\np.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\n\n\n# In[46]:\n\n\nsns.set_style(\"ticks\") # A diferença com o anterior são os \"ticks\" no eixo x\np = sns.relplot(x = 'data', y='Óbitos', hue = 'Tipo', data=covid_PB_obitos_df.reset_index(), kind='line')\np.fig.autofmt_xdate()\np.ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7)) #Intervalo entre os tracinhos\np.ax.xaxis.set_major_locator(mdates.DayLocator(interval=21)) #Intervalo entre as datas\np.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y')) #Formato da data\np.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\n\n\n# ### Molduras\n# \n# Utilizamos a função `despine` para adicionar ou remover molduras em plotagens com o *seaborn*. Podemos especificar lados para adicionar e remover molduras utilizando os booleanos `True` e `False`.\n\n# In[47]:\n\n\nsns.set_style(\"ticks\")\np = sns.relplot(x = 'data', y='Óbitos', hue = 'Tipo', data=covid_PB_obitos_df.reset_index(), kind='line')\np.fig.autofmt_xdate()\np.ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7)) \np.ax.xaxis.set_major_locator(mdates.DayLocator(interval=21)) \np.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y'))\np.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\nsns.despine(right=False, top=False)\n\n\n# Podemos criar um tipo de \"acolchoamento\" aumentando a distância entre o gráfico e a moldura utilizando `offset`. Atribuindo um valor para este argumento, as bordas serão afastadas naturalmente. Um tipo de \"corte estético\" pode ser adicionado à moldura com `trim=False`.\n\n# In[48]:\n\n\nsns.set_style(\"ticks\")\np = sns.relplot(x = 'data', y='Óbitos',\n                hue = 'Tipo',\n                data=covid_PB_obitos_df.reset_index(),\n                kind='line')\np.fig.autofmt_xdate()\np.ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7)) #Intervalo entre os tracinhos\np.ax.xaxis.set_major_locator(mdates.DayLocator(interval=21)) #Intervalo entre as datas\np.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y')) #Formato da data\np.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\nsns.despine(right=False, top=False, offset=30)\n\n\n# In[49]:\n\n\nsns.set_style(\"ticks\")\np = sns.relplot(x = 'data', y='Óbitos',\n                hue = 'Tipo',\n                data=covid_PB_obitos_df.reset_index(),\n                kind='line')\np.fig.autofmt_xdate()\np.ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7)) #Intervalo entre os tracinhos\np.ax.xaxis.set_major_locator(mdates.DayLocator(interval=21)) #Intervalo entre as datas\np.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y')) #Formato da data\np.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\nsns.despine(offset=30, trim=True)\n\n\n# ### Contextos e escala\n# \n# O *seaborn* possui contextos pré-definidos que mudam a escala do gráfico para melhor satisfazer a aplicação de interesse. Para definir o contexto, utilizamos a função `set_context`. Há 4 contextos pré-definidos: *paper*, *notebook*, *talk* e *poster*.\n\n# In[50]:\n\n\nsns.set_context(\"poster\")\nsns.set_style(\"ticks\")\np = sns.relplot(x = 'data', y='Óbitos', \n                hue = 'Tipo',\n                data=covid_PB_obitos_df.reset_index(),\n                kind='line')\np.fig.autofmt_xdate()\np.ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7)) #Intervalo entre os tracinhos\np.ax.xaxis.set_major_locator(mdates.DayLocator(interval=21)) #Intervalo entre as datas\np.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y')) #Formato da data\np.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\n\n\n# In[51]:\n\n\nsns.set_context(\"talk\")\nsns.set_style(\"ticks\")\np = sns.relplot(x = 'data', y='Óbitos', hue = 'Tipo', data=covid_PB_obitos_df.reset_index(), kind='line')\np.fig.autofmt_xdate()\np.ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7)) #Intervalo entre os tracinhos\np.ax.xaxis.set_major_locator(mdates.DayLocator(interval=21)) #Intervalo entre as datas\np.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y')) #Formato da data\np.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\n\n\n# In[52]:\n\n\nsns.set_context(\"notebook\")\nsns.set_style(\"ticks\")\np = sns.relplot(x = 'data', y='Óbitos', hue = 'Tipo', data=covid_PB_obitos_df.reset_index(), kind='line')\np.fig.autofmt_xdate()\np.ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7)) #Intervalo entre os tracinhos\np.ax.xaxis.set_major_locator(mdates.DayLocator(interval=21)) #Intervalo entre as datas\np.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y')) #Formato da data\np.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\n\n\n# In[53]:\n\n\nsns.set_context(\"paper\")\nsns.set_style(\"ticks\")\np = sns.relplot(x = 'data', y='Óbitos', hue = 'Tipo', data=covid_PB_obitos_df.reset_index(), kind='line')\np.fig.autofmt_xdate()\np.ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7)) #Intervalo entre os tracinhos\np.ax.xaxis.set_major_locator(mdates.DayLocator(interval=21)) #Intervalo entre as datas\np.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y')) #Formato da data\np.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\n\n\n# ### Paletas e mapas de cores\n# \n# É possível personalizar a paleta de cores a ser utilizada ou escolher uma da lista (extremamente extensa) de paletas disponíveis utilizando a função `set_palette`. Duas formas usuais de selecionar a paleta de cores são:\n# \n# - no escopo de uma instrução `with` por meio da função `color_palette`;\n# - pelo argumento `palette` nas funções de construção gráfica.\n# \n# A função `color_palette()` aceita nomes de uma paleta do _seaborn_ (_deep_, _muted_, _bright_, _pastel_,_dark_,_colorbind_), um mapa de cores (_colormap_) do _matplotlib_, uma sequência de cores em qualquer formato aceitável pelo _matplotlib_, entre outras opções.\n# \n# ```{note}\n# Para uma lista ampla de paletas, veja a discussão neste [post](https://medium.com/@morganjonesartist/color-guide-to-seaborn-palettes-da849406d44f) ou a [_Colormap reference_](https://matplotlib.org/stable/gallery/color/colormap_reference.html) do _matplotlib_.\n# ```\n\n# Abaixo temos alguns exemplos de paletas nativas do _seaborn_\n\n# In[54]:\n\n\nsns.color_palette()\n\n\n# In[55]:\n\n\nsns.color_palette('colorblind')\n\n\n# In[56]:\n\n\nsns.color_palette('bright')\n\n\n# e de mapas do cores do _matplotlib_.\n\n# In[57]:\n\n\nsns.color_palette('Greens')\n\n\n# In[58]:\n\n\nsns.color_palette('turbo')\n\n\n# In[59]:\n\n\nsns.color_palette('cividis')\n\n\n# Nos exemplos a seguir, plotamos alguns gráficos novamente com paletas diferentes.\n\n# In[60]:\n\n\n# paleta: 'BuPu'\nsns.set_context(\"paper\")\nsns.set_style(\"ticks\")\np = sns.relplot(x = 'data', y='Óbitos', \n                hue = 'Tipo', \n                data=covid_PB_obitos_df.reset_index(), kind='line',\n                palette = 'BuPu')\np.fig.autofmt_xdate()\np.ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7)) #Intervalo entre os tracinhos\np.ax.xaxis.set_major_locator(mdates.DayLocator(interval=21)) #Intervalo entre as datas\np.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y')) #Formato da data\np.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\n\n\n# In[61]:\n\n\n# paleta: 'mako_r'\nwith sns.color_palette('mako_r'):\n    p = sns.catplot(x='Região', y='Óbitos', \n                    kind = 'violin',\n                    data=covid_regioes_diarios_px)\n    p.ax.set_xlabel(''); p.fig.set_size_inches(12,4)\n\n\n# In[62]:\n\n\n# paleta: icefire_r\nsns.set_palette('icefire_r')\n_ = sns.jointplot(x='obitos_Nordeste', y='obitos_Sudeste', \n                  data = covid_regioes_diarios, \n                  height=6)\n\n\n# ## Nota\n# \n# Este capítulo baseia-se nas notas de aula da Profa. Andrea Rocha (CI/UFPB), elaboradas para o mini-curso [FMECD](https://gcpeixoto.github.io/FMECD/ipynb/01a-introducao.html).\n", "meta": {"hexsha": "6769bc52a96e5cb1358b18a8a3c0b7181f167be9", "size": 28798, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/ipynb/16-visualizacao-dados-seaborn.py", "max_stars_repo_name": "gcpeixoto/ICD", "max_stars_repo_head_hexsha": "bae7d02cd467240649c89b0ba4440966fba18cc7", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-09-09T01:56:40.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-10T01:56:56.000Z", "max_issues_repo_path": "_build/jupyter_execute/ipynb/16-visualizacao-dados-seaborn.py", "max_issues_repo_name": "gcpeixoto/ICD", "max_issues_repo_head_hexsha": "bae7d02cd467240649c89b0ba4440966fba18cc7", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/ipynb/16-visualizacao-dados-seaborn.py", "max_forks_repo_name": "gcpeixoto/ICD", "max_forks_repo_head_hexsha": "bae7d02cd467240649c89b0ba4440966fba18cc7", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-23T14:24:03.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-23T14:24:03.000Z", "avg_line_length": 32.6878547106, "max_line_length": 372, "alphanum_fraction": 0.6954302382, "include": true, "reason": "import numpy,from scipy", "num_tokens": 8590, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4610167941228965, "lm_q2_score": 0.16885695632426873, "lm_q1q2_score": 0.07784589266996432}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # NAM 2019 pMuTT Workshop\n# \n# Instructions and materials for the \"Theory, Applications, and Tools for Kinetic Modeling\" workshop can be found on [our documentation page](https://vlachosgroup.github.io/pMuTT/nam_2019.html).\n# \n\n# # Table of Contents\n# \n# | **1\\. [Virtual Kinetic Laboratory Ecosystem](#section_1)**\n# \n# | **2\\. [Useful Links](#section_2)**\n# \n# | **3\\. [Constants](#section_3)**\n# \n# |-- **3.1. [Access common constants in appropriate units](#section_3_1)**\n# \n# |-- **3.2. [Convert between units](#section_3_2)**\n# \n# |-- **3.3. [Convert between equivalent quantities](#section_3_3)**\n# \n# | **4\\. [Exercise 1](#section_4)**\n# \n# | **5\\. [Creating statistical mechanical objects using StatMech](#section_5)**\n# \n# |-- **5.1. [Supported StatMech models](#section_5_1)**\n# \n# |--|-- **5.1.1 [Translations](#section_5_1_1)**\n# \n# |--|-- **5.1.2. [Vibrations](#section_5_1_2)**\n# \n# |--|-- **5.1.3. [Rotations](#section_5_1_3)**\n# \n# |--|-- **5.1.4. [Electronic](#section_5_1_4)**\n# \n# |--|-- **5.1.5. [Miscellaneous](#section_5_1_5)**\n# \n# |-- **5.2. [Initializing StatMech modes individually](#section_5_2)**\n# \n# |-- **5.3. [Initializing StatMech modes using presets](#section_5_3)**\n# \n# | **6\\. [Plot Thermodynamic Quantities](#section_6)**\n# \n# | **7\\. [Exercise 2](#section_7)**\n# \n# | **8\\. [Creating empirical objects](#section_8)**\n# \n# |-- **8.1. [Inputting a NASA polynomial directly](#section_8_1)**\n# \n# |-- **8.2. [Fitting an empirical object to a StatMech object](#section_8_2)**\n# \n# | **9\\. [Input/Output](#section_9)**\n# \n# |-- **9.1. [Input via Excel](#section_9_1)**\n# \n# |-- **9.2. [Output via Thermdat](#section_9_2)**\n# \n# | **10\\. [Reactions](#section_10)**\n# \n# | **11\\. [Exercise 3](#section_11)**\n# \n# | **12\\. [Solutions](#section_12)**\n# \n# |-- **12.1. [Solution 1](#section_12_1)**\n# \n# |-- **12.2. [Solution 2](#section_12_2)**\n# \n# |-- **12.3. [Solution 3](#section_12_3)**\n\n# <a id='section_1'></a>\n\n# # 1. Virtual Kinetic Laboratory Ecosystem\n# \n# <img src=\"images/SoftwareEcosystem1.svg\" width=600>\n# \n# \n# <img src=\"images/pmutt_logo.png\" width=400>\n# \n# - Estimates thermochemical and kinetic parameters using statistical mechanics, transition state theory\n# - Writes input files for kinetic models and eases thermodynamic analysis\n# - Implemented in Python\n#   - Easy to learn\n#   - Heavily used in scientific community\n#   - Object-oriented approach is a natural analogy to chemical phenomenon\n# - Library approach allows users to define the starting point and end point\n# \n# <img src=\"images/workflow.png\" width=600>\n# \n\n# <a id='section_2'></a>\n\n# # 2. Useful Links\n# \n# - [Documentation](https://vlachosgroup.github.io/pMuTT/): find the most updated documentation\n# - [Issues](https://github.com/VlachosGroup/pmutt/issues): report bugs, request features, receive help\n# - [Examples](https://vlachosgroup.github.io/pMuTT/examples.html): see examples\n\n# <a id='section_3'></a>\n\n# # 3. Constants\n# \n# The [constants module](https://vlachosgroup.github.io/pMuTT/constants.html) has a wide variety of functions for constants and unit conversion.\n\n# <a id='section_3_1'></a>\n\n# ## 3.1. Access common constants in appropriate units\n# Below, we access Planck's constant in J s.\n\n# In[1]:\n\n\nfrom pmutt import constants as c\n\nh1 = c.h('eV s', bar=True)\nprint('h = {} eV s'.format(h1))\n\n\n# <a id='section_3_2'></a>\n\n# ## 3.2. Convert between units\n# Below, we convert 12 atm of pressure to psi.\n\n# In[2]:\n\n\nfrom pmutt import constants as c\n\nP_atm = 12. # atm\nP_psi = c.convert_unit(num=P_atm, initial='atm', final='psi')\n\nprint('{} atm = {} psi'.format(P_atm, P_psi))\n\n\n# <a id='section_3_3'></a>\n\n# ## 3.3. Convert between equivalent quantities\n# Below, we convert 1000 wavenumbers (cm-1) to frequency.\n\n# In[3]:\n\n\nfrom pmutt import constants as c\n\nwave_num = 1000. # cm-1\nfreq = c.wavenumber_to_freq(wave_num) # Hz\n\nprint('{} cm-1 = {} Hz'.format(wave_num, freq))\n\n\n# <a id='section_4'></a>\n\n# # 4. Exercise 1\n# \n# Using `pmutt.constants`, calculate the dimensionless enthalpy (H/RT) using the following information:\n# - H = 0.5 eV\n# - T = 77 F\n\n# In[4]:\n\n\n# Fill in your answer for Exercise 1 here\n\n\n# <a id='section_5'></a>\n\n# # 5. Creating statistical mechanical objects using StatMech\n# \n# Molecules show translational, vibrational, rotational, electronic, and nuclear modes.\n# \n# <img src=\"images/statmech_modes.jpg\" width=800>\n\n# <a id='section_5_1'></a>\n\n# ## 5.1. Supported StatMech modes\n# \n# <img src=\"images/StatMech2.svg\" width=800>\n# \n# The StatMech object allows us to specify translational, vibrational, rotational, electronic and nuclear modes independently, which gives flexibility in what behavior you would like. Below are the available modes.\n\n# <a id='section_5_1_1'></a>\n\n# ### 5.1.1. Translations\n# - [``FreeTrans``](https://vlachosgroup.github.io/pMuTT/statmech.html#freetrans) - Translations assuming no intermolecular interactions\n\n# <a id='section_5_1_2'></a>\n\n# ### 5.1.2. Vibrations\n# - [``HarmonicVib``](https://vlachosgroup.github.io/pMuTT/statmech.html#harmonicvib) - Harmonic vibrations\n# - [``QRRHOVib``](https://vlachosgroup.github.io/pMuTT/statmech.html#harmonicvib) - Quasi rigid rotor harmonic oscillator. Low frequency modes are treated as rigid rotations.\n# - [``EinsteinVib``](https://vlachosgroup.github.io/pMuTT/statmech.html#einsteinvib) - Each atom in the crystal vibrates as independent 3D harmonic oscillators\n# - [``DebyeVib``](https://vlachosgroup.github.io/pMuTT/statmech.html#debyevib) - Improves upon ``EinsteinVib`` by considering simultaneous vibrations. Improves accuracy at lower temperatures.\n\n# <a id='section_5_1_3'></a>\n\n# ### 5.1.3. Rotations\n# - [``RigidRotor``](https://vlachosgroup.github.io/pMuTT/statmech.html#rigidrotor) - Molecule can be rotated with no change in bond properties\n\n# <a id='section_5_1_4'></a>\n\n# ### 5.1.4. Electronic\n# - [``GroundStateElec``](https://vlachosgroup.github.io/pMuTT/statmech.html#groundstateelec) - Electronic ground state of the system\n# - [``LSR``](https://vlachosgroup.github.io/pMuTT/statmech.html#linear-scaling-relationships-lsrs) - Linear Scaling Relationship to estimate binding energies using reference adsorbate\n\n# <a id='section_5_1_5'></a>\n\n# ### 5.1.5. Miscellaneous\n# - [``EmptyMode``](https://vlachosgroup.github.io/pMuTT/statmech.html#empty-mode) - Default mode if not specified. Does not contribute to any properties\n# - [``ConstantMode``](https://vlachosgroup.github.io/pMuTT/statmech.html#constant-mode) - Specify arbitrary values to thermodynamic quantities\n# \n# Using a ``StatMech`` mode gives you access to all the common thermodynamic properties.\n# \n# <img src=\"images/StatMech_obj.png\" width=400>\n# \n# For this example, we will use a hydrogen molecule as an ideal gas:\n# - translations with no interaction between molecules\n# - harmonic vibrations\n# - rigid rotor rotations\n# - ground state electronic structure\n# - no contribution from nuclear modes.\n# \n# <img src=\"images/H2_1.jpg\" width=200>\n\n# <a id='section_5_2'></a>\n\n# ## 5.2. Initializing StatMech modes individually\n\n# In[5]:\n\n\nfrom ase.build import molecule\nfrom pmutt.statmech import StatMech, trans, vib, rot, elec\n\nH2_atoms = molecule('H2')\n\n'''Translational'''\nH2_trans = trans.FreeTrans(n_degrees=3, atoms=H2_atoms)\n\n'''Vibrational'''\nH2_vib = vib.HarmonicVib(vib_wavenumbers=[4342.]) # vib_wavenumbers in cm-1\n\n'''Rotational'''\nH2_rot = rot.RigidRotor(symmetrynumber=2, atoms=H2_atoms)\n\n'''Electronic'''\nH2_elec = elec.GroundStateElec(potentialenergy=-6.77,spin=0) # potentialenergy in eV\n\n'''StatMech Initialization'''\nH2_statmech = StatMech(name='H2',\n                       trans_model=H2_trans,\n                       vib_model=H2_vib,\n                       rot_model=H2_rot,\n                       elec_model=H2_elec)\n\n'''Calculate thermodynamic properties'''\nH_statmech = H2_statmech.get_H(T=298., units='kJ/mol')\nS_statmech = H2_statmech.get_S(T=298., units='J/mol/K')\nprint('H_H2(T=298 K) = {:.1f} kJ/mol'.format(H_statmech))\nprint('S_H2(T=298 K) = {:.2f} J/mol/K'.format(S_statmech))\n\n\n# <a id='section_5_3'></a>\n\n# ## 5.3. Initializing StatMech modes using presets\n# \n# Commonly used models can be accessed via [``presets``](https://vlachosgroup.github.io/pMuTT/statmech.html#presets). The currently supported models are:\n# \n# - [``idealgas``](https://vlachosgroup.github.io/pMuTT/statmech.html#ideal-gas-idealgas) - Ideal gases\n# - [``harmonic``](https://vlachosgroup.github.io/pMuTT/statmech.html#harmonic-approximation-harmonic) - Typical for surface species\n# - [``electronic``](https://vlachosgroup.github.io/pMuTT/statmech.html#electronic-electronic) - Only has electronic modes\n# - [``placeholder``](https://vlachosgroup.github.io/pMuTT/statmech.html#placeholder-placeholder) - No contribution to any property\n# - [``constant``](https://vlachosgroup.github.io/pMuTT/statmech.html#constant-constant) - Use arbitrary constants to thermodynamic properties\n# \n\n# In[6]:\n\n\nfrom ase.build import molecule\nfrom pmutt.statmech import StatMech, presets\n\nH2_statmech = StatMech(atoms=molecule('H2'),\n                       vib_wavenumbers=[4342.], # cm-1\n                       symmetrynumber=2,\n                       potentialenergy=-6.77, # eV\n                       spin=0.,\n                       **presets['idealgas'])\n\n'''Calculate thermodynamic properties'''\nH_statmech = H2_statmech.get_H(T=298., units='kJ/mol')\nS_statmech = H2_statmech.get_S(T=298., units='J/mol/K')\nprint('H_H2(T=298 K) = {:.1f} kJ/mol'.format(H_statmech))\nprint('S_H2(T=298 K) = {:.2f} J/mol/K'.format(S_statmech))\n\n\n# <a id='section_6'></a>\n\n# # 6. Plot Thermodynamic Quantities\n# Use [`pmutt.plot_1D`](https://vlachosgroup.github.io/pMuTT/visual.html#plot-1d) and [`pmutt.plot_2D`](https://vlachosgroup.github.io/pMuTT/visual.html#plot-2d) to plot any function with respect to 1 or 2 variables.\n\n# In[7]:\n\n\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfrom pmutt import plot_1D, plot_2D\n\nT = np.linspace(300., 500.)\n\nf1, ax1 = plot_1D(H2_statmech,\n                  x_name='T', x_values=T,\n                  methods=('get_H', 'get_S', 'get_G'),\n                  get_H_kwargs={'units': 'kcal/mol'},\n                  get_S_kwargs={'units': 'cal/mol/K'},\n                  get_G_kwargs={'units': 'kcal/mol'})\nf1.set_size_inches(6, 6)\nf1.set_dpi(200)\nplt.show()\n\n\n# <a id='section_7'></a>\n\n# # 7. Exercise 2\n# \n# 1. Create a ``StatMech`` object for ideal gas-phase H2O. The necessary inputs are given below.\n# \n# |            Parameter           |             Value            |\n# |--------------------------------|------------------------------|\n# |              atoms             |       `molecule('H2O')`      |\n# |      Potential Energy (eV)     |            -6.7598           |\n# |         Symmetry number        |               2              |\n# |              Spin              |               0              |\n# | Vibrational Wavenumbers (cm-1) | 3825.434, 3710.264, 1582.432 |\n# \n# 2. Calculate the Gibbs energy in eV for H2O at T = 500 K and P = 2 bar.\n# \n# 3. Create a ``StatMech`` object for a Cu crystal using the ``DebyeVib`` model for the vibration mode and ``GroundStateElec`` model for electronic mode. The necessary inputs are given below.\n# \n# | Parameter              | Value      |\n# |------------------------|------------|\n# | Debye Temperature (K)  | 310        |\n# | Interaction energy (eV)| 0          |\n# | Potential energy (eV)  | -14.922356 |\n# \n# 4. Plot the H (in eV) and S (in eV/K) for Cu between T = 300 - 700 K.\n\n# In[8]:\n\n\n# Fill in your answer for Exercise 2 here\n\n# 1.\n\n\n# 2.\n\n\n# 3.\n\n\n# 4.\n\n\n# <a id='section_8'></a>\n\n# # 8. Creating empirical objects\n# Currently, pMuTT supports [NASA polynomials](https://vlachosgroup.github.io/pMuTT/empirical.html#nasa) and [Shomate polynomials](https://vlachosgroup.github.io/pMuTT/empirical.html#shomate). They can be initialized in three ways:\n# - passing in the polynomials directly\n# - from a model (e.g. ``StatMech``, ``Shomate``) (``from_model``)\n# - from heat capacity, enthalpy and entropy data (``from_data``)\n# \n# <img src=\"images/nasa_func1.png\" width=400>\n\n# <a id='section_8_1'></a>\n\n# ## 8.1. Inputting a NASA polynomial directly\n# \n# The H2 NASA polynomial from the [Burcat database](http://combustion.berkeley.edu/gri_mech/version30/files30/thermo30.dat) is represented as:\n# \n# ```\n# H2                TPIS78H   2               G   200.000  3500.000  1000.000    1\n#  3.33727920E+00-4.94024731E-05 4.99456778E-07-1.79566394E-10 2.00255376E-14    2\n# -9.50158922E+02-3.20502331E+00 2.34433112E+00 7.98052075E-03-1.94781510E-05    3\n#  2.01572094E-08-7.37611761E-12-9.17935173E+02 6.83010238E-01                   4\n# ```\n# \n# This can be translated to pMuTT syntax using:\n\n# In[9]:\n\n\nfrom pmutt.empirical.nasa import Nasa\n\n# Initialize NASA polynomial\nH2_nasa = Nasa(name='H2',\n               elements={'H': 2},\n               phase='G',\n               T_low=200., T_mid=1000., T_high=3500.,\n               a_low=[2.34433112E+00, 7.98052075E-03, -1.94781510E-05,\n                      2.01572094E-08, -7.37611761E-12, -9.17935173E+02,\n                      6.83010238E-01],\n               a_high=[3.33727920E+00, -4.94024731E-05, 4.99456778E-07,\n                       -1.79566394E-10, 2.00255376E-14, -9.50158922E+02,\n                       -3.20502331E+00])\n\n# Calculate thermodynamic quantities using the same syntax as StatMech\nH_H2 = H2_nasa.get_H(units='kcal/mol', T=298.)\nprint('H_H2(T=298 K) = {} kcal/mol'.format(H_H2))\n\n# Show thermodynamic quantities vs. T\nT = np.linspace(200., 3500.)\nf2, ax2 = plot_1D(H2_nasa,\n                  x_name='T', x_values=T,\n                  methods=('get_H', 'get_S', 'get_G'),\n                  get_H_kwargs={'units': 'kcal/mol'},\n                  get_S_kwargs={'units': 'cal/mol/K'},\n                  get_G_kwargs={'units': 'kcal/mol'})\nf2.set_size_inches(6, 6)\nf2.set_dpi(200)\nplt.show()\n\n\n# <a id='section_8_2'></a>\n\n# ## 8.2. Fitting an empirical object to a StatMech object\n# Empirical objects can be made directly using ``StatMech`` objects and the ``from_model`` method.\n\n# In[10]:\n\n\nH2_nasa = Nasa.from_model(name='H2',\n                          T_low=200.,\n                          T_high=3500.,\n                          model=H2_statmech)\n\n# Compare the statistical mechanical model to the empirical model\nf3, ax3 = H2_nasa.plot_statmech_and_empirical(Cp_units='J/mol/K',\n                                              H_units='kJ/mol',\n                                              S_units='J/mol/K',\n                                              G_units='kJ/mol')\nf3.set_size_inches(6, 8)\nf3.set_dpi(200)\nplt.show()\n\n\n# <a id='section_9'></a>\n\n# # 9. Input/Output\n# pMuTT has more IO functionality than below. See this page for [supported IO functions](https://vlachosgroup.github.io/pMuTT/io.html).\n\n# <a id='section_9_1'></a>\n\n# ## 9.1. Input via Excel\n# \n# Encoding each object in Python can be tedious. You can read several species from Excel spreadsheets using [``pmutt.io.excel.read_excel``](https://vlachosgroup.github.io/pmutt/io.html?highlight=read_excel#pmutt.io.excel.read_excel). Note that this function returns a list of dictionaries. This output allows you to initialize whichever object you want using kwargs syntax. There are also [special rules that depend on the header name](https://vlachosgroup.github.io/pMuTT/io.html#special-rules).\n# \n# Below, we show an example importing species data from a spreadsheet and creating a series of NASA polynomials.\n\n# In[11]:\n\n\nimport os\nfrom pprint import pprint\nfrom pathlib import Path\nfrom pmutt.io.excel import read_excel\nfrom pmutt.empirical.nasa import Nasa\n\n# Find the location of Jupyter notebook\n# Note that normally Python scripts have a __file__ variable but Jupyter notebook doesn't.\n# Using pathlib can overcome this limiation\ntry:\n    notebook_folder = os.path.dirname(__file__)\nexcept NameError:\n    notebook_folder = Path().resolve()\nos.chdir(notebook_folder)\n\n# Read the data from Excel\nab_initio_data = read_excel(io='./input/NH3_Input_Data.xlsx', sheet_name='species')\npprint(ab_initio_data)\n\n\n# In[12]:\n\n\n# Create NASA polynomials using **kwargs syntax\nnasa_species = []\nfor species_data in ab_initio_data:\n    single_nasa_species = Nasa.from_model(T_low=100.,\n                                          T_high=1500.,\n                                          **species_data)\n    nasa_species.append(single_nasa_species)\n\n# Print out a table using enthalpy, entropy, Gibbs energy at 298 K for each species\nprint('Name         Enthalpy (kcal/mol)   Entropy (cal/mol/K)   Gibbs energy (kcal/mol)')\nprint('--------------------------------------------------------------------------------')\nfor single_nasa_species in nasa_species:\n    name = single_nasa_species.name\n    H = single_nasa_species.get_H(units='kcal/mol', T=298.)\n    S = single_nasa_species.get_S(units='cal/mol/K', T=298.)\n    G = single_nasa_species.get_G(units='kcal/mol', T=298.)\n    print('{:12}       {:10.1f}       {:15.1f}       {:15.1f}'.format(name, H, S, G))\n    \n\n\n# <a id='section_9_2'></a>\n\n# ## 9.2. Output via Thermdat\n# The thermdat format uses NASA polynomials to represent several species. It has a very particular format so doing it manually is error-prone. You can write a list of ``Nasa`` objects to thermdat format using [``pmutt.io.thermdat.write_thermdat``](https://vlachosgroup.github.io/pmutt/io.html#pmutt.io.thermdat.write_thermdat). \n# \n# Below, we write a thermdat file using the species imported from the spreadsheet.\n\n# In[13]:\n\n\nfrom pmutt.io.thermdat import write_thermdat\n\nwrite_thermdat(filename='./output/thermdat', nasa_species=nasa_species)\n\n\n# Similarly, a list of ``Nasa`` objects can be read from a thermdat using [``pmutt.io.thermdat.read_thermdat``](https://vlachosgroup.github.io/pMuTT/io.html#pmutt.io.thermdat.read_thermdat). \n\n# In[14]:\n\n\nfrom pmutt.io.thermdat import read_thermdat\n\nnasa_species = read_thermdat('./output/thermdat')\n\n\n# <a id='section_10'></a>\n\n# # 10. Reactions\n# \n# <img src=\"images/reaction.png\" width=800>\n# \n# ``Reaction`` objects can be created by putting together ``Nasa``, ``Shomate`` and ``StatMech`` objects.\n# \n# <img src=\"images/reaction_func1.png\" width=800>\n# \n# \n# The ``from_string`` method is the easiest way to create a ``Reaction`` object. It requires the relevant species to be in a dictionary and a string to describe the reaction.\n# \n# <img src=\"images/reaction_string.svg\" width=800>\n# \n# We will demonstrate its use for the formation of NH3.\n\n# In[15]:\n\n\nfrom pmutt.empirical.nasa import Nasa\nfrom pmutt.empirical.shomate import Shomate\nfrom pmutt.reaction import Reaction\n\n# Create species. Note that you can mix different types of species\nspecies = {\n    'H2': StatMech(name='H2', atoms=molecule('H2'),\n                   vib_wavenumbers=[4342.], # cm-1\n                   symmetrynumber=2,\n                   potentialenergy=-6.77, # eV\n                   spin=0.,\n                   **presets['idealgas']),\n    'N2': Nasa(name='N2', T_low=300., T_mid=643., T_high=1000.,\n               a_low=[3.3956319945669633, 0.001115707689025668,\n                      -4.301993779374381e-06, 6.8071424019295535e-09,\n                      -3.2903312791047058e-12, -191001.55648623788,\n                      3.556111439828502],\n               a_high=[4.050329990684662, -0.0029677854067980108,\n                       5.323485005316287e-06, -3.3518122405333548e-09,\n                       7.58446718337381e-13, -191086.2004520406,\n                       0.6858235504924011]),\n    'NH3': Shomate(name='NH3', T_low=300., T_high=1000.,\n                   a=[18.792357134351683, 44.82725349479501,\n                      -10.05898449447048, 0.3711633831565547,\n                      0.2969942466370908, -1791.225746924463,\n                      203.9035662274934, 1784.714638346206]),\n}\n\n# Define the formation of water reaction\nrxn = Reaction.from_string('1.5H2 + 0.5N2 = NH3', species)\n\n# Calculate forward change in enthalpy\nH_rxn_fwd = rxn.get_delta_H(units='kcal/mol', T=300.)\nprint('Delta H_fwd(T = 300 K) = {:.1f} kcal/mol'.format(H_rxn_fwd))\n\n# Calculate reverse change in enthalpy\nH_rxn_rev = rxn.get_delta_H(units='kcal/mol', T=300., rev=True)\nprint('Delta H_rev(T = 300 K) = {:.1f} kcal/mol'.format(H_rxn_rev))\n\n# Calculate enthalpy of reactants\nH_react = rxn.get_H_state(units='kcal/mol', T=300., state='reactants')\nprint('H_reactants(T = 300 K) = {:.1f} kcal/mol'.format(H_react))\n\n\n# <a id='section_11'></a>\n\n# ## 11. Exercise 3\n# \n# 1. Use [``pmutt.io.thermdat.read_thermdat``](https://vlachosgroup.github.io/pMuTT/io.html#pmutt.io.thermdat.read_thermdat) to read the thermdat from './output/thermdat'.\n# \n# 2. Convert the list of ``Nasa`` to a dictionary of ``Nasa`` using ``pmutt.pmutt_list_to_dict``. The syntax to use the function is shown below.\n# \n# ```\n# from pmutt import pmutt_list_to_dict\n# \n# species_dict = pmutt_list_to_dict(species_list)\n# ```\n# \n# 3. Create a ``Reaction`` from the string: ``NH3(S) + RU(S) = TS1_NH3(S) = NH2(S) + H(S)`` and the dictionary from step 2.\n# \n# 4. Calculate the forward reaction enthalpy in kcal/mol at 298 K using [``Reaction.get_delta_H``](https://vlachosgroup.github.io/pMuTT/reactions.html#pmutt.reaction.Reaction.get_E_act).\n# \n# 5. Calculate the forward activation energy in kcal/mol at 298 K using [``Reaction.get_E_act``](https://vlachosgroup.github.io/pMuTT/reactions.html#pmutt.reaction.Reaction.get_E_act).\n\n# In[16]:\n\n\n# Fill in your answer for Exercise 3\n\n# 1.\n\n\n# 2.\n\n\n# 3. \n\n\n# 4.\n\n\n# 5.\n\n\n# <a id='section_12'></a>\n\n# # 12. Solutions\n\n# <a id='section_12_1'></a>\n\n# ## 12.1. Solution to Exercise 1\n# [Link to Exercise 1](#section_4)\n\n# In[17]:\n\n\nfrom pmutt import constants as c\n\n# Define information given\nH = 0.5 # eV\nT = 77 # F\n\n# Calculate H/RT\nHoRT = H/c.R('eV/K')/c.convert_unit(77, initial='F', final='K')\nprint('H/RT = {}'.format(HoRT))\n\n\n# <a id='section_12_2'></a>\n\n# ## 12.2. Solution to Exercise 2\n# [Link to Exercise 2](#section_7)\n\n# In[18]:\n\n\nfrom ase.build import molecule\nfrom pmutt import plot_1D\nfrom pmutt.statmech import StatMech, presets\nfrom pmutt.statmech.vib import DebyeVib\nfrom pmutt.statmech.elec import GroundStateElec\n\n# 1. Create H2O molecule\nH2O_statmech = StatMech(atoms=molecule('H2O'),\n                        potentialenergy=-6.7598,\n                        symmetrynumber=2,\n                        spin=0,\n                        vib_wavenumbers=[3825.434, 3710.264, 1582.432],\n                        **presets['idealgas'])\n\n\n# 2. Calculate Gibbs energy of H2O at T = 500 K and P = 2 bar\nT = 500. # K\nP = 2. # bar\nG_H2O = H2O_statmech.get_G(units='eV', T=T, P=P)\nprint('G_H2O(T = 500 K, P = 2 bar) = {} eV'.format(G_H2O))\n\n\n# 3. Create Cu crystal\nCu_vib = DebyeVib(debye_temperature=310., interaction_energy=0.)\nCu_elec = GroundStateElec(potentialenergy=-14.922356)\nCu_statmech = StatMech(vib_model=Cu_vib, elec_model=Cu_elec)\n\n\n# 4. Plot the 1D profile for H and S between 300 K and 700 K\nT = np.linspace(300., 700.) # K\nf2, ax2 = plot_1D(Cu_statmech,\n                  x_name='T', x_values=T,\n                  methods=('get_H', 'get_S'),\n                  get_H_kwargs={'units': 'eV'},\n                  get_S_kwargs={'units': 'eV/K'})\nf2.set_size_inches(6, 6)\nf2.set_dpi(200)\nplt.show()\n\n\n# <a id='section_12_3'></a>\n\n# ## 12.3. Solution to Exercise 3\n# [Link to Exercise 3](#section_11)\n\n# In[19]:\n\n\nfrom pmutt.io.thermdat import read_thermdat\nfrom pmutt import pmutt_list_to_dict\nfrom pmutt.reaction import Reaction\n\n# 1. Read the thermdat file\nspecies_list = read_thermdat('./output/thermdat')\n\n# 2. Convert the list of Nasa to a dictionary of Nasa\nspecies_dict = pmutt_list_to_dict(species_list)\n\n# 3. Create a Reaction from the specified string\nrxn = Reaction.from_string('NH3(S) + RU(S) = TS1_NH3(S) = NH2(S) + H(S)', species_dict)\n\n# 4. Calculate the reaction enthalpy\nH_rxn = rxn.get_delta_H(units='kcal/mol', T=298.)\nprint('H_rxn = {:.1f} kcal/mol'.format(H_rxn))\n\n# 5. Calculate the forward activation energy\nEa = rxn.get_E_act(units='kcal/mol', T=298.)\nprint('Ea_fwd = {:.1f} kcal/mol'.format(Ea))\n\n", "meta": {"hexsha": "548253ec6e02040f75c65ffd18ea5f2f32689835", "size": 24071, "ext": "py", "lang": "Python", "max_stars_repo_path": "docs/source/examples_jupyter/nam2019/NAM_2019_Workshop.py", "max_stars_repo_name": "wittregr/pMuTT", "max_stars_repo_head_hexsha": "1678fd3d3a10d8ef5389c02970a7ebaa92fc7344", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 28, "max_stars_repo_stars_event_min_datetime": "2018-10-29T17:44:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T14:20:16.000Z", "max_issues_repo_path": "docs/source/examples_jupyter/nam2019/NAM_2019_Workshop.py", "max_issues_repo_name": "wittregr/pMuTT", "max_issues_repo_head_hexsha": "1678fd3d3a10d8ef5389c02970a7ebaa92fc7344", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 101, "max_issues_repo_issues_event_min_datetime": "2018-10-18T19:49:30.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-19T10:59:57.000Z", "max_forks_repo_path": "docs/source/examples_jupyter/nam2019/NAM_2019_Workshop.py", "max_forks_repo_name": "wittregr/pMuTT", "max_forks_repo_head_hexsha": "1678fd3d3a10d8ef5389c02970a7ebaa92fc7344", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 16, "max_forks_repo_forks_event_min_datetime": "2018-12-15T17:01:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-03T17:42:23.000Z", "avg_line_length": 32.8390177353, "max_line_length": 496, "alphanum_fraction": 0.651323169, "include": true, "reason": "import numpy", "num_tokens": 7437, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44552953503957277, "lm_q2_score": 0.1732882059293266, "lm_q1q2_score": 0.07720501381553461}}
{"text": "# -*- coding: utf-8 -*-\r\n\"\"\"\r\nSpyder Editor\r\n\r\nThis is a temporary script file.\r\n\"\"\"\r\n\"\"\"-------------------------------------------------------------------------------------------------------------------------------------------------------------- \"\"\"\r\n\r\n\"\"\"\r\n자료구조 : 1. sequence 자료구조 (순서있음)\r\n          2. 딕셔너리, 세트 (순서없음)\r\n\r\n인덱싱 : 리스트에서 하나의 요소를 인덱스 연산자를 통하여 참조(접근)하는 것\r\n\r\n슬라이싱 : 리스트 안에서 범위를 지정하여서 원하는 요소들을 선택하는 연산\r\n\r\n리스트 : 여러 개의 데이터가 저장되어 있는 자료구조\r\n리스트가 필요한 이유 : 여러 개의 데이터가 저장되어 있는 자료구조\r\n\"\"\"\r\n\r\n# 문자열 인덱싱 & 슬라이싱\r\n\r\ntext = \"IT Will is power.\"\r\nprint(text[:-2]) # IT Will is powe\r\nprint(text[:8], text[-1])\r\n\r\n# 인덱싱\r\nflist = [\"apple\", \"banana\", \"tomato\", \"peach\", \"pear\" ]\r\nprint(flist[0], flist[3], flist[-1])\r\n\r\n# 슬라이싱\r\na = [0,1,4,9,16,25,36,49]\r\na[3:6]\r\n\r\n# 리스트 (append로 추가해서 리스트를 만들어보는 것)\r\n\r\nscores = [ ]\r\nfor i in range(10):\r\n    scores.append(int(input(\"성적을 입력하시오:\")))\r\nprint(scores)\r\n\r\nscores[0] = 80\r\n\r\nscores[i] = 10;\r\nscores[i+2] = 20;\r\n\r\n# 리스트의 요소갯수만큼 리스트가 반복되어 출력\r\nfor element in scores:\r\n    print(scores)\r\n\r\n# 복잡한 리스트\r\nlist1 = [12,\"dog\",180.14] # 혼합자료형\r\nlist2 = [[\"Seoul\", 10], [\"Paris\", 12], [\"London\", 50]] # 내장 리스트\r\n\r\n# 리스트 기초연산\r\nmarvel_heroes = [ \"스파이더맨\", \"헐크\", \"아이언맨\" ]\r\ndc_heroes = [ \"슈퍼맨\", \"배트맨\", \"원더우먼\" ]\r\n\r\nheros = marvel_heroes + dc_heroes\r\nheros\r\n# 리스트에 곱하기\r\nvalues = [1,2,3]*3\r\nvalues # [1, 2, 3, 1, 2, 3, 1, 2, 3]\r\nlen(values)\r\n \r\n# 요소추가하기\r\ndevelopteam = []\r\ndevelopteam.append(\"이유현\")\r\ndevelopteam.append(\"성민승\")\r\ndevelopteam.append(\"김동완\")\r\n\r\ndevelopteam\r\n\r\n# 리스트 안의 내용 조회\r\nif \"이유현\" in developteam:\r\n    print(\"내부인원\")\r\n    \r\n# 리스트 인덱스 확인\r\ndevelopteam.index(\"이유현\") # 0\r\ndevelopteam.index(\"김동완\") # 2\r\n\r\n# 리스트 최소값 최대값\r\nvalues = [ 100, 20, 31, 45, 15, 6, 7, 8, 9, 10 ]\r\nmin(values)\r\nmax(values)\r\n\r\n# 리스트에서 sort 쓰기 정렬~~~\r\nvalues.sort()\r\nvalue2=sorted(values)\r\nprint(value2)\r\n\r\n# 리스트 내의 조건문\r\nlist1 = [3,4,5]\r\nlist2 = [x*2 for x in list1]\r\nprint(list2)\r\n\r\n# 2차원 리스트\r\ns = [ \r\n[ 1, 2, 3, 4, 5 ] ,\r\n[ 6, 7, 8, 9, 10 ], \r\n[11, 12, 13, 14, 15 ] \r\n]\r\n\r\nprint(s)\r\n\r\n# 동적으로 2차원 리스트 생성\r\n\r\nrows = 3\r\ncols = 5\r\n\r\ns = []\r\nfor row in range(rows):\r\n    s += [[3]*cols]\r\n    \r\nprint(\"s=\",s) # s= [[3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3]]\r\n\r\nrows = len(s)\r\ncols = len(s[0])\r\ncols\r\nfor r in range(rows):\r\n    for c in range(cols):\r\n        print(s[r][c], end=\",\")\r\n    print()\r\n\r\n\"\"\"\r\n    tuple!! \r\n    튜플은 변경될 수 없는 리스트 + 순서가 없다!!\r\n    \r\n    tuple('listname') \r\n    : 리스트를 튜플로 변경한다.\r\n\"\"\"\r\n# tuple을 변경하려고 해보자\r\n\r\nt1 = (1,2,3,4,5);\r\nt2 = (1,2,3,4,5);\r\n\r\nt1[0] =100; # TypeError: 'tuple' object does not support item assignment\r\n\r\n# 튜플 대입 연산\r\nstudent1 = (\"철수\",19,\"CS\")\r\n(name,age,major) = student1\r\nname # '철수'\r\n\r\n\"\"\"\r\n    set!!\r\n    세트는 중복되지 않은 항목들이 모인것 + 순서가 없다!!\r\n    \r\n\"\"\"\r\n\r\nnumbers = {1,2,2,3,3,3,4}\r\n\r\nnumbers # {1, 2, 3, 4}\r\n\r\n# 요소 추가\r\nnumbers.add(5)\r\n\r\n\r\n\"\"\"\r\n\r\n    dictionary\r\n    딕셔너리는 키(key)와 값(value)의 쌍을 저장할 수 있는 객체\r\n    \r\n\r\n\"\"\"\r\n\r\n# 형태\r\ndictionary = {'name':'이유현','phone':'01091597160','score':100}\r\ndictionary['score']\r\n# 추가하기\r\n\r\ndictionary['speed'] = '1000'\r\nprint(dictionary)\r\n\r\n# 항목 순회하며 출력하기.\r\n\r\nfor item in dictionary.items():\r\n    print(item)\r\n\"\"\"\r\n--------------------------------------------------------------------------------------------------------------------------------------------------------------------\r\n    plot 문제로 정리하기\r\n    1. matplotlib\r\n        1) 한글 및 음수 부호 지원\r\n        2) 기본차트 시각화 - 기본 선 스타일과 색상, x축 y축 스타일&색상, color와 marker 이용\r\n        3) 산점도, 히스토그램, 상자그래프\r\n        3) 이산형 변수 시각화 - 가로막대 그래프, 세로막대 차트, 원차트\r\n        4) subplot 차트\r\n        5) 시계열차트\r\n--------------------------------------------------------------------------------------------------------------------------------------------------------------------\r\n\"\"\"\r\n\r\ndata3= np.random.randn(50) # 난수\r\ndata4= np.random.randn(50).cumsum() # 난수\r\n\r\nchart.plot(data3, color='r', label='step', \r\ndrawstyle=\"steps-post\")\r\n\r\nchart.plot(data4, color='g', label='line')\r\nplt.legend(loc='best')\r\nplt.ylabel('y label')\r\nplt.xlabel('x label')\r\nplt.title('chart title')\r\nplt.show()\r\n\r\nimport matplotlib.pyplot as plt\r\nimport seaborn as sn\r\n\r\n# 문3) seaborn의  titanic 데이터셋을 이용하여 다음과 같이 단계별로 시각화하시오.\r\ntitanic = sn.load_dataset('titanic')\r\nprint(titanic.info())\r\n\r\n#  <단계1> 'total_bill','tip','sex','size' 칼럼으로 서브셋 만들기  \r\ntitanic_df = titanic[['survived','pclass', 'age','fare']]\r\nprint(titanic_df.info())\r\n#sn.pairplot(data=DataFrame, hue='집단변수', kind='scatter')\r\n\r\n# <단계2> 성별(sex) 칼럼을 집단변수로 산점도행렬 시각화\r\nsn.pairplot(data=titanic_df, hue='survived')\r\nplt.show()\r\n\r\n# <단계3> 산점도행렬의 시각화 결과 해설하기\r\n'''\r\npclass : 3등석 일수록 사망비율 매우 높음 \r\npclass vs fare : 1등석 일수록 고 요금 \r\nage : 25~50세 사이에서 가장 높은 빈도, 사망과 생존 비율 비슷 \r\nage vs fare : 대체적으로 나이가 많고, 요금이 낮은 경우 사망 비율 높음\r\nfare : 비용이 저렴한 경우가 상대적으로 많은 분포\r\nfare vs age : 대체적으로 요금이 낮고, 나이가 50대 이상인 경우 사망 비율 높음    \r\n'''\r\n\r\n# survived vs age    \r\n# 연령대 생존비율 : 20~40 \r\ntitanic[titanic['survived'] == 1].age.plot(kind = 'hist', color = 'blue')\r\n# 연령대 사망비율 : 20~40\r\ntitanic[titanic['survived'] == 0].age.plot(kind = 'hist', color = 'green')\r\n\r\n\r\n# 문4) seaborn의 tips 데이터셋을 이용하여 다음과 같이 단계별로 시각화하시오.\r\ntips = sn.load_dataset('tips')\r\nprint(tips.info())\r\n\r\n# <단계1> 'total_bill','tip','sex','size' 칼럼으로 서브셋 만들기\r\ntips_df = tips[['total_bill','tip','sex','size']]\r\n\r\n# <단계2> 성별(sex) 칼럼을 집단변수로 산점도행렬 시각화 \r\nsn.pairplot(data=tips_df, hue='sex')\r\nplt.show()\r\n\r\n# <단계3> 산점도행렬의 시각화 결과 해설하기\r\n\"\"\"\r\ntotal_bill : 총금액 15~20 사이가 가장 높은 빈도, 금액이 클 수록 남자 지불  \r\ntotal_bill vs tip  : 대체적으로 비례관계, 총금액과 팁이 많은 경우 남자 지불\r\ntip : 팁은 1~5 사이가 가장 높은 빈도, 팁 금액이 클 수록 남자 지불 \r\ntotal_bill vs size : 행사규모가 작은 경우 여성 지불\r\nsize : 행사규모 2가 가장 높은 빈도, 특히 4일때 남자 지불 \r\nsize vs total_bill : 대체적으로 비례관계, 규모가 큰 경우 총금액이 많음  \r\n\r\n\"\"\"\r\nimport pandas as pd # object\r\nimport numpy as np # dataset\r\nimport matplotlib.pyplot as plt # plt.show() \r\n\r\n# 1. 기본 차트 시각화 \r\nser = pd.Series(np.random.randn(10)) # 1d \r\nprint(ser)\r\n\r\n# 1차원 객체 : 기본차트 - 선 그래프 \r\nser.plot(color='g')\r\nplt.show()\r\n\r\n# 2차원 객체 \r\ndf = pd.DataFrame(np.random.randn(10, 4),\r\n                  columns=('one','two','three','fore'))\r\n\r\nprint(df)\r\n\r\n# 기본차트 : 선 그래프\r\ndf.plot()  \r\nplt.show()\r\n\r\n# 막대차트 : 세로 \r\ndf.plot(kind='bar', title = 'bar chart')\r\nplt.show()\r\n\r\n\r\n# 막대차트 : 가로 \r\ndf.plot(kind='barh', title = 'bar chart')\r\nplt.show()\r\n\r\n\r\n# 막대차트 : 가로, 누적형  \r\ndf.plot(kind='barh', title = 'barh chart', stacked=True)\r\nplt.show() \r\n\r\n\r\n# 2. dataset 이용 \r\nimport os\r\n\r\nos.chdir('C:/ITWILL/4_Python-II/data')\r\ntips = pd.read_csv('tips.csv')\r\nprint(tips.info())\r\n\r\n# 교차분할표 : 집단변수 이용 \r\n# 요일(day):행 vs 규모(size):열\r\ntips['day'].unique() # ['Sun', 'Sat', 'Thur', 'Fri']\r\ntips['size'].unique()# [2, 3, 4, 1, 6, 5]\r\n\r\ntab = pd.crosstab(index=tips['day'], columns=tips['size'])\r\nprint(tab)\r\n\r\n# 테이블 정보 \r\ntab.shape # (4, 6)\r\ntab.index # 행 이름 \r\ntab.columns # 열 이름 \r\n\r\n#tab.index = 수정 이름 \r\ntype(tab) # pandas.core.frame.DataFrame\r\n\r\nhelp(tab.plot)\r\n\r\n# size : 1, 6 제외 -> subset\r\n#obj.loc[행, 열]\r\nnew_tab = tab.loc[:, 2:5]\r\nprint(new_tab)\r\n\r\n\r\nnew_tab.plot(kind='barh', stacked=True,\r\n         title = 'day and size')\r\nplt.show()\r\n\r\n\r\n\r\n\"\"\"\r\n---------------------------------------------------------------------------------------------------------------------------------------------------------------------\r\nplot 예제 끝~~\r\n\"\"\"\r\n\r\n\"\"\"\r\n---------------------------------------------------------------------------------------------------------------------------------------------------------------------\r\n\r\n1. Group by : 머 대강 칼럼들을 특정 변수의 조건에 맞게 그룹화 시키는거다\r\n2. apply :\r\n3. Pivot table ---> df.pivot(index='x',columns='y',values='z')\r\n        - 좌측 index(행)를 어떤 칼럼으로 설정할지\r\n        - 칼럼(열)쪽을 y칼럼으로 세우고\r\n        - 안에 채울 values 값 z로 설정\r\n\r\n\r\n---------------------------------------------------------------------------------------------------------------------------------------------------------------------\r\n\"\"\"\r\n\r\n\"\"\"\r\n\r\nNUMPY!!!!!!!!!!!!!\r\n    1. 배열 생성 array()\r\n    - arange() : 배열 객체 반환\r\n    - linspace() : 시작점과 끝점을 균일 간격으로 나눈 점들을 생성\r\n    - reshape() : 행수와 열수를 조절\r\n    2. 특수 행렬 생성 zeros() : 0으로 채워진 배열, ones() : 1로 채워진 배열 ,eye() : 항등행렬\r\n    \r\n    3. 난수 생성  numpy.random.normal(size = 개수)\r\n    4. 산술연산 \r\n\r\n\"\"\"\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\"\"\"\r\n# Series Pandas의 Series는 1차원 데이터를 다루는 데 효과적인 자료구조\r\nvalues 속성을 호출하면 데이터의 배열 원소가 리턴\r\nindex 속성을 호출하면 인덱스의 정보가 리턴\r\n각각의 데이터는 [인덱스]를 이용해서 접근이 가능\r\nnumpy 함수 사용 가능\r\ndict 객체로 생성 가능\r\n\"\"\"\r\n# code 1\r\n\r\nfrom pandas import Series, DataFrame\r\nimport numpy as np\r\nimport pandas as pd\r\n\r\nprice = Series([4000, 3000, 3500, 2000])\r\nprint(price)\r\nprint(price.index)\r\nprint(price.values)\r\nprint('====================')\r\nfruit = Series([4000, 3000, 3500, 2000], \r\nindex=['apple', 'mellon','orange', 'kiwi'])\r\nprint(fruit)\r\nprint(fruit[0]) # 순번 이용 데이터 접근\r\nprint(fruit['apple']) # 인덱스 이용 데이터 접근\r\nprint(fruit[fruit>3000]) # 부울리언 식\r\nprint(\"=================\")\r\n\r\n# code 2\r\nfrom pandas import Series, DataFrame\r\nimport numpy as np\r\nimport pandas as pd\r\n\r\ngood1 = Series([4000,3500,None,2000],index = ['apple','mango','orange','kiwi'])\r\n\r\ngood2 = Series([3000,3000,3500,2000],index = ['apple','mango','orange','kiwi'])\r\n\r\nprint(pd.isnull(good1)) # NaN값 검출 none이면 True를 반환\r\nprint (good1+good2)\r\n\r\n\r\n# DataFrame\r\n\r\n\"\"\"\r\n# DataFrame은 행과 열로 구성된 2차원 데이터를 다루는 데 효과적인 자료구조\r\n일반적으로 딕셔너리 활용해서 생성\r\n입력가능한 데이터\r\n1. 2차원 ndarray\r\n2. 리스트, 튜플,dict, Series의 dict\r\n3. dict, Series의 list\r\n4. 리스트, 튜플의 리스트\r\n5. 칼럼 뽑는 방법\r\n    1) data.iloc[[행]],[열]  # 행은 index\r\n\r\n\"\"\"\r\n# code 1\r\nfrom pandas import Series, DataFrame\r\n\r\nitems = {'code': [1,2,3,4,5,6],\r\n'name': ['apple','watermelon','oriental melon', 'banana', 'lemon', 'mango'],\r\n'manufacture': ['korea', 'korea', 'korea','philippines','korea', 'taiwan'],\r\n'price':[1500, 15000,1000,500,1500,700]}\r\n\r\ndata = DataFrame(items)\r\nprint(data)\r\n\r\n# 특정 컬럼만 뽑기\r\ndata1 = DataFrame(items, columns = ['code', 'price'])\r\nprint(data1)\r\nprint(data.loc[0]) # 0 행 출력 가로로 나옴\r\nprint(data.loc[:0]) # 0 행 출력 세로로 나옴\r\nprint(data.loc[[2],['name']])\r\n\r\n\r\n# 데이터 프레임 변경해보기\r\ndata.index = np.arange(1,7,1) # 1~6까지 인덱스 설정\r\ndata.columns\r\ndata = data.reindex(['1','2','3','4','5','7'],columns = ['code', 'name', 'manufacture', 'price'])\r\nprint(data.index)\r\nprint(data);\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\"\"\"-------------------------------------------------------------------------------------------------------------------------------------------------------------- \"\"\"\r\n# 정규분포 생성 알고리즘\r\n\"\"\" 정규분포란? 가우시안 정규 분포 :\r\n    자연 현상에서 나타나는 숫자를 확률 모형으로 모형화할 때 가장 많이 사용되는 모형\r\n    표준편차 1배안에 전체 데이터의 약 70% 이상이 몰려있고\r\n    1.96배 안에 95% 이상이 분포된 경우\r\n    \"\"\"\r\nfrom pandas import Series, DataFrame\r\nimport pandas as pd\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\nfrom matplotlib import font_manager, rc \r\nfrom scipy import stats\r\nimport scipy as sp \r\nfont_name = font_manager.FontProperties(fname=\"c:/Windows/Fonts/malgun.ttf\").get_name()\r\nrc('font', family=font_name)\r\nmu = 0 \r\nstd = 1\r\nrv = sp.stats.norm(mu, std) \r\nxx = np.linspace(-5, 5, 100)\r\nplt.plot(xx, rv.pdf(xx))\r\nplt.ylabel(\"확률\")\r\nplt.title(\"정규분포곡선\")\r\nplt.show() \r\nx = rv.rvs(100) # rvs 메서드로 시뮬레이션해 샘플을 얻는것\r\n\r\nprint(x)\r\n\r\n# 검정통계 , 유의확률(p-value)\r\n\"\"\"\r\n    검정(testing)은  데이터  뒤에  숨어있는  확률  변수의  분포와  모수에  대한  가설의  진 위를  정량적(quantitatively)으로  증명하는  작업\r\n    \r\n    실제 모집단에서 표본 몇 십 개 또는 몇 백 개를 추출해서 그것의 분산(표본분산)이나 평균(표본평균)을 사용해야 하는 경우가 대 부분입니다.\r\n   표본수가  크지  않을  때  표본분산(표본표준편차)을  사용한  테스트는  t-분포를  이용 한다고  해서  T-test라고  합니다.\r\n   가설  증명  즉  검정의  기본적인  논리는  다음과  같습니다.\r\n   만약  가설이  맞다면  즉, 모수  값이  특정한  조건을  만족한다면  해당  확률  변수로부터  만 들어진  표본(sample) 데이터들은  어떤  규칙을  따르게  된다.\r\n    해당 규칙에 따라 표본 데이터 집합에서 어떤 숫자를 계산하면 계산된 숫자는 특정한 확률 분포를 따르게 된다. 이 숫자를 검정 통계치(test statistics)라고 하며 확률 분포를 검정 통계 분포(test statistics distribution)라고 한다. 검정 통계 분포의 종류 및 모수의 값은 처음에 정한 가설에 의해 결정된다. 이렇게 검정 통계 분포를 결정하는 최초의 가 설을 귀무 가설(Null hypothesis)이라고 한다.\r\n   데이터에  의해서  실제로  계산된  숫자, 즉, 검정  통계치가  해당  검정  통계  분포에서  나올 수  있는  확률을  계산한다. 이를  유의  확률(p-value)라고  한다.\r\n   만약  유의  확률이  미리  정한  특정한  기준  값보다  작은  경우를  생각하자. 이  기준  값을 유의  수준(significance level)이라고  하는  데  보통  1% 혹은  5% 정도의  작은  값을  지정한 다. 유의  확률이  유의  수준으로  정한  값(예  1%)보다도  작다는  말은  해당  검정  통계  분포 에서  이  검정  통계치가  나올  수  있는  확률이  아주  작다는  의미이므로  가장  근본이  되는 가설  즉, 귀무  가설이  틀렸다는  의미이다. 따라서  이  경우에는  귀무  가설을  기각(reject) 한다.\r\n   만약 유의 확률이 유의 수준보다 크다면 해당 검정 통계 분포에서 이 검정 통계치가 나 오는 것이 불가능하지만은 않다는 의미이므로 귀무 가설을 기각할 수 없다. 따라서 이 경우에는 귀무 가설을 채택(accept)한다.\r\n    \r\n    linspace 함수는 numpy모듈의 1차원 배열 만드는 함수\r\n    x = np.linspace(start,stop,num) # num은 요소의 개수 그 사이에 몇개를 만들것인가.\r\n    np.random.randit : 균일 분포의 정수 난수 1개 생서\r\n    np.random.rand : 0부터 1사이의 난수 matrix array 생성\r\n    np.random.randn : 가우시안 표준 정규 분포에서 난수 matrix array 생성\r\n    plt.fill_between() : 두 수평 방향의 곡선 사이를 채웁니다.\r\n    plt.fill_betweenx() : 두 수평 방향의 곡선 사이를 채웁니다.\r\n    plt.fill() : 다각형 영역을 채웁니다.\r\n    \r\n    \r\n    파이썬 플랏 상세 설명 : https://blog.naver.com/nach3012/222419686483\r\n    \r\n\"\"\"\r\n\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\nfrom matplotlib import font_manager, rc \r\nfrom scipy import stats\r\nimport scipy as sp\r\n\r\nfont_name = font_manager.FontProperties(fname=\"c:/Windows/Fonts/malgun.ttf\").get_name() \r\nrc('font', family=font_name)\r\n\r\nxx1 = np.linspace(-4, 4, 100) \r\nxx2 = np.linspace(-4, -2, 100) \r\nxx3 = np.linspace(2, 4, 100)\r\n\r\nplt.fill_between(xx1, sp.stats.norm.pdf(xx1), facecolor='green', alpha=0.1)\r\nplt.fill_between(xx2, sp.stats.norm.pdf(xx2), facecolor='blue', alpha=0.35)\r\nplt.fill_between(xx3, sp.stats.norm.pdf(xx3), facecolor='blue', alpha=0.35)\r\nplt.text(-3, 0.1, \"p-value=%5.3f\" % (2*sp.stats.norm.cdf(-2)), horizontalalignment='center')\r\nplt.title(\"유의확률:0.046\") \r\nplt.show()\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n", "meta": {"hexsha": "a1d71f23fcce75e8776076eaa8c1e4d4dbc5c4e2", "size": 13360, "ext": "py", "lang": "Python", "max_stars_repo_path": "basic.py", "max_stars_repo_name": "LYH-93/LYH-93.github.io", "max_stars_repo_head_hexsha": "bc40cb18c94b6781e6df37a8c6b67625ae8ae3df", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "basic.py", "max_issues_repo_name": "LYH-93/LYH-93.github.io", "max_issues_repo_head_hexsha": "bc40cb18c94b6781e6df37a8c6b67625ae8ae3df", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "basic.py", "max_forks_repo_name": "LYH-93/LYH-93.github.io", "max_forks_repo_head_hexsha": "bc40cb18c94b6781e6df37a8c6b67625ae8ae3df", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.4797891037, "max_line_length": 323, "alphanum_fraction": 0.5420658683, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 6063, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44939263446475963, "lm_q2_score": 0.17106119801750538, "lm_q1q2_score": 0.07687364243178466}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Useful Introduction to Python, GitHub, and LaTex\n# Questions that you may be asking:\n# - What is Python?\n# - Why should I use it?\n# - Is it venemous?\n# - Why am I talking to myself?\n# \n# In this chapter, you are going to learn the answers to some of these questions and develop some basic skills.  These skills will be useful in later chapters and will form a springboard so that you can dive into the ocean that is Computational Physics.  The first thing that you may need is motivation, which lies in the history of scientific computing.\n# \n# ## A History\n# \n# A **computer** is a machine that can carryout sequences of arithmetic or logical operations.  It requires instructions in a specific order (i.e., syntax), and space to hold intermediate/final results (i.e., memory).  Prior to the 20th Century, a computer was a mechanical device that allowed users to perform arithmetic calculations quickly.  An abacus is one such device:\n# \n# | ![abacus](https://upload.wikimedia.org/wikipedia/commons/a/af/Abacus_6.png) |\n# |:--:| \n# |The Chinese suanpan. The number represented on this abacus is 6,302,715,408. (wikipedia:abacus)|\n# \n# The principle of the modern computer was proposed by **Alan Turing** (1936) in his paper <em>On Computable Numbers</em>. Turing proposed a \"Universal Computing machine\" that is capable of computing anything that is computable by executing instructions (program) stored on tape, allowing the machine to be programmable. The fundamental concept of Turing's design is the stored program, where all the instructions for computing are stored in memory. **Von Neumann** acknowledged that the central concept of the modern computer was due to this paper.\n# \n# **Colossus** was the world's first electronic digital programmable computer, where it used a large number of valves (vacuum tubes). It had paper-tape input and was capable of being configured to perform a variety of boolean logical operations on its data.  The **ENIAC** (Electronic Numerical Integrator and Computer) was the first electronic programmable computer built in the United States. Like the Colossus, a \"program\" on the ENIAC was defined by the states of its patch cables and switches. Once a program was written, it had to be mechanically set into the machine with the manual resetting of plugs and switches. \n# \n# | ![ENIAC](https://upload.wikimedia.org/wikipedia/commons/thumb/4/4e/Eniac.jpg/1280px-Eniac.jpg)\n# |:--:| \n# |ENIAC was the first electronic device in the U.S. and performed ballistics trajectory calculations for the United States Army. (wikipedia:computer)|\n# \n# Along with military applications, computers became the catalyst for many scientific and engineering breakthroughs.  In the 1950s, IBM developed the programming language **FORTRAN** (Formula Translation) as a general-purpose, compiled imperative programming language that is especially suited to numeric computation and scientific computing.  Many scientific programs were developed in FORTRAN and are still in use today in computationally intensive areas such as numerical weather prediction, finite element analysis, computational fluid dynamics, geophysics, **computational physics**, crystallography and computational chemistry.\n# \n# Before the development of disk files, text editors and terminals, programs were most often entered on a keypunch keyboard onto 80-column punched cards, one line to a card. The resulting deck of cards would be fed into a card reader to be compiled. Punched card codes included no lower-case letters or many special characters, and special versions of the IBM 026 keypunch were offered that would correctly print the re-purposed special characters used in FORTRAN.  Reflecting punched card input practice, FORTRAN programs were originally written in a fixed-column format, with the first 72 columns read into twelve 36-bit words.\n# \n# | ![Punchcard](https://upload.wikimedia.org/wikipedia/commons/5/58/FortranCardPROJ039.agr.jpg)\n# |:--:| \n# |FORTRAN code on a punched card, showing the specialized uses of columns 1–5, 6 and 73–80. (wikipedia:fortran)|\n# \n\n# ## Why Python?\n# \n# Fast-forwarding from punchcards to the modern era, other computer languages (C, C++, Java) were developed to improve upon FORTRAN in terms of their usage (i.e., easier to code) and compilation speed.  FORTRAN has also changed over many versions that migrated it from punchcards to completely digital files.  The programming language C rivals FORTRAN for speed and has become the backbone of modern computing.  Back to Python.  What is it?\n# \n# Python is a scripting language, which means it takes commands in a more human-like language and translates those commands into machine code (zeros and ones).  The Python interpreter does this one line at a time, but its translation into machine code is less efficient than C or FORTRAN.  For applications where speed is key, Python is used as an interface while portions of the code are passed into the speedier languages.  Alternatively, one can develop their Python code using C extensions for Python (or Cython).\n# \n# Scientists are quickly adopting Python within a range of fields because it is open-source (i.e., free) and much easier for students to learn.  Especially if you have any prior experience in programming, where Python strips away many of the quirks from legacy languages.  <em>Due to the simplified structure of Python programs, you can easily begin programming and get to your results. </em>\n# \n\n# ##  Python Basics\n# \n# ### Create a Jupyter Notebook\n# \n# **To create a Jupyter notebook in Microsoft VS Code**: open the command palette (Windows: Ctrl + Shift + P, iOS: Command + Shift + P) and select the command \"Jupyter: Create New Blank Notebook\".\n# \n# Python programs include 3 elements: 1) import statements/libraries, 2) custom functions, and 3) regular statements.  Although this document has flowing text, most Python programs are written to be as short as possible.  For these examples, we are using an interactive Python mode, where code blocks are designated with \n# > In [ ]:\n# \n# for input. These codeblocks can be run and re-run with tweaks, but you need to watch out for dependencies (i.e., assumptions that some other code exists in memory).  Let's start by importing a commonly used modules **numpy** and **matplotlib**\n\n# In[1]:\n\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\n# These import statements will allow us to use functions with the respective modules.  The numpy module was developed to make managing data structures easier, while the matplotlib library introduces functions from the <em>Matlab Plotting Library </em> so that we can visualize our results.  To produce a graph, let's first generate some data:\n\n# In[2]:\n\n\nx = np.arange(1,5,0.5)\ny = 3*x + 2\n\n\n# The first line uses the 'arange' function from numpy, where we use 'np' as a shortcut label.  The 'arange' function takes in up to 3 values as input: starting value, stopping value, and step size to generate a numpy array with an interated sequence:\n# \n# >x = np.array([1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5])\n# \n# Note that the generated values are floats (i.e., real numbers) and the final value of the array is 4.5 and **not** 5.0.  Python generators typically exclude the end point.  If we wanted to use integers (i.e., whole numbers) instead, then we could have used the 'range' function from pure Python without refferring to the numpy module and excluded the step size as input (e.g., range(0,5)).\n# \n# The second line generates another numpy array using the values stored in 'x'.  More precisely, it makes a temporary copy of 'x', where it performs a multiplication by 3 and addition of 2 to each element of the copied array.  Finally, the temporary copied array is stored as a variable called 'y'.\n# \n# >y = np.array([ 5. ,  6.5,  8. ,  9.5, 11. , 12.5, 14. , 15.5])\n\n# Now, we are going to make a plot of the data that we generated.  To create a canvas in matplotlib, we start with the figure function and store it in a container called 'fig'.  The suptitle function uses a string (i.e., array of characters) as input and sets the keyword argument fontsize equal to 16 pt font.  We also introduce a container 'ax' that holds the axes for the canvas through the add_subplot function that takes a three digit number (row column index) as input.\n\n# In[3]:\n\n\nfig = plt.figure()\nfig.suptitle('My first graph', fontsize=16)\nax = fig.add_subplot(111)\nax.plot(x,y,'k.',ms=18)\n\n\n# To plot our generated data, we simply used the plot function on the axes (the Axes class inherits the plot function from the matplotlib module).  The plot function used the x and y arrays to generate the points, but we also had to tell it that we wanted black points ('k.') with a markersize (ms) equal to 18 pts.\n# \n# However, we may want to make a lot of plots and do not want to copy/paste a bunch of times.  To reuse our commands, we define a custom function 'create_plot' that takes the parameters we may want to vary as input.\n\n# In[4]:\n\n\ndef create_plot(x,y,color,marker,ms):\n    fig = plt.figure()\n    fig.suptitle('My first graph', fontsize=16)\n    ax = fig.add_subplot(111)\n    ax.plot(x,y,marker=marker,color=color,ms=18,lw=0)\n\n\n# Notice that Python uses a tab to delineate what should be included in the function.  Now let's change the color to blue ('b'), the marker to squares ('s') and the markersize to 12 points.\n\n# In[5]:\n\n\ncreate_plot(x,y,'b','s',12)\n\n\n# We can even change the x,y values to something more complicated.\n\n# In[6]:\n\n\nx = np.arange(0,2*np.pi,0.5)\ny = 3*np.sin(x+1)-2\ncreate_plot(x,y,'r','^',1)\n\n\n# There are many options within matplotlib, where you will find some more useful than others over time.  If in doubt, you can always check the **matplotlib gallery** (https://matplotlib.org/stable/gallery/index.html) or stackexchange (https://stackexchange.com/).  It is likely that someone has already run into your problem/customization and other people have provided a 'possible' solution (<em>not all solutions are good!</em>).  The last bit of customization for this section is to:\n# \n# 1. add axis labels\n#     - ax.set_xlabel(*string,fontsize=22) or ax.set_ylabel(*string,fontsize=22)\n# 2. modify tick marks \n#     - ax.tick_params(axis='both', direction='out',length = 12.0, width = 8.0)\n# 3. modify tick labels\n#     - using ```$``` opens the latex interpreter for custom symbols (e.g., ```$\\pi$``` = $\\pi$)\n#     - ax.set_xticklabels(['0','$\\pi$/2','$\\pi$','$3\\pi/2$','2$\\pi$'])\n# 4. set sensible axis limits\n#     - ax.set_xlim(0,2*np.pi)\n# 5. add a legend\n#     - add the keyword 'label' to the plot command and set equal to a string\n#     - ax.legend(loc='upper right',fonstize=20)\n\n# In[7]:\n\n\nfig = plt.figure()\nfig.suptitle('My first graph', fontsize=16)\nax = fig.add_subplot(111)\nax.plot(x,y,marker='*',color='orange',ms=18,lw=0,label='SHO')\n\nax.set_xlabel(\"Angle (rad.)\",fontsize=22)\nax.set_ylabel(\"Amplitude (ft/s)\",fontsize=22)\nax.tick_params(axis='both', direction='out',length = 12.0, width = 8.0)\nax.set_xlim(0,2*np.pi)\nax.set_xticks([0,np.pi/2,np.pi,3.*np.pi/2.,2*np.pi])\nax.set_xticklabels(['0','$\\pi$/2','$\\pi$','$3\\pi/2$','2$\\pi$'])\nax.legend(loc='upper center',fontsize=20)\n\n\n# Figures can be saved to file using the `savefig` function, which takes the filename as an argument.  Additional keyword arguments (kwargs) can be applied that alter the display of the figure (e.g., dpi = 300 sets the dots per inch to 300).\n\n# In[ ]:\n\n\nfig.savefig(\"SHO.png\",bbox_inches='tight',dpi=300)\n\n\n# ### Modules to solve problems\n# \n# There are many modules within modules, where object-oriented notation is used to access them.  For example, you can generate a random number between 0--1 using the rand() function within the random module within the numpy module (i.e., np.random.rand()).\n\n# In[ ]:\n\n\nnp.random.rand()\n\n\n# Another extremely useful library for physicists is the linear algebra package in numpy. This package provides very fast routines for calculating anything having to do with matrices: eigenvalues, eigenvectors, solutions of systems of linear equations, and so on.\n# \n# >Example 1: In electronics, Kirchhoff's laws are used to solve for the currents through components in circuit networks. Applying these laws gives us systems of linear equations, which can then be expressed as matrix equations, such as:\n# \n# ![Kirchoff](Kirchoff_matrix.png)\n\n# In[ ]:\n\n\nA = np.matrix([[-13,2,4],[2,-11,6],[4,6,-15]]) #matrix is an array of an array\nB = np.array([5,-10,5])\nnp.linalg.solve(A,B)\n\n\n# ### Reading and writing data from a file\n\n# Python allows for many forms of input.  There are commands to request user input manually via the terminal window, where this can be a direct request or by command line arguments.  For computational physics, it is likely that you want to know how the output of a program changes with slightly different inputs or to visualize a data set.  At this point manual input is impractical and cumbersome.  In this section, you will learn how to read and write to data files so that you can save your work for later or prepare it for others to use.  Files are created using the open() function that takes a filename and a mode as input.  Here's a table detailing the different modes available to the open() function.\n# \n# | Character   | Meaning |\n# | ----------- | :-----------: |\n# | 'r'      | reading from a file; returns error if not found |\n# | 'w'   | writing to a file; creates a new file/overwrites existing file) |\n# | 'x'   | open for exclusive creation; failing if the file already exists |\n# | 'a'   | open for writing; appending to the end of the file if it exists |\n# | 'b'   | binary mode |\n# | 't'   | text mode (default) |\n# | '+'   | open for updating (reading and writing) |\n# \n# Let's generate some data using the equation for a simple pendulum:\n# \n# $\\ddot{\\theta} = \\sqrt{\\frac{g}{l}} \\theta$,\n# \n# which has the solution\n# \n# $\\theta(t) = \\theta_{max} \\sin \\left(\\sqrt{\\frac{g}{l}} t \\right)$,\n# \n# where $g$ represents the acceleration due to gravity, $l$ is the length, and $t$ is the time.  Now let's define some variables.\n# \n\n# In[ ]:\n\n\ng = 9.81 #m/s^2 Earth gravity near the surface\nl = 1 #meter long string\nt = np.arange(0,10.5,0.01) #10 seconds with 0.5 sec increments\ntheta_max = 45 #maximum amplitude in degrees\nfname = \"Simple_Pendulum.txt\"\n\ntheta = theta_max*np.sin(np.sqrt(g/l)*t)\nout = open(fname,'w') #create a text file and open it for writing\nout.write(\"#time (s), theta (deg)\\n\") #write a header\n\nfor i in range(0,len(t)):\n    out.write(\"%1.2f, %1.3f\\n\" % (t[i],theta[i]))\nout.close()\n\n\n# The data is written to \"Simple_Pendulum.txt\", which exists in the same directory as this Jupyter notebook.  In practice, you may want to include an absolute path in the filename.  Using our code from before, we will read the data from the file.  Notice that we formatted the header with a \\# symbol and the lines are comma delimited.  We are going to take advantage of this using the 'genfromtxt' function from numpy.\n\n# In[ ]:\n\n\nx,y = np.genfromtxt(\"Simple_Pendulum.txt\",delimiter=',',comments='#',unpack=True)\n\nfig = plt.figure()\nfig.suptitle('Simple Pendulum', fontsize=16)\nax = fig.add_subplot(111)\nax.plot(x,y,'r-',lw=3)\n\nax.set_xlabel(\"Time (s)\",fontsize=22)\nax.set_ylabel(\"Amplitude (deg)\",fontsize=22)\nax.tick_params(axis='both', direction='out',length = 12.0, width = 8.0)\nax.set_xlim(0,10)\nax.set_xticks(np.arange(0,12,2))\n\n\n# ## GitHub\n# \n# GitHub is a platform used by many disciplines to make code easier to develop, track, store, and share.  The platform provides a series of [guides](https://guides.github.com/) that introduce new users through common practices on GitHub.  In this section, we will focus on the [Hello World](https://guides.github.com/activities/hello-world/) guide.  Throughout the course, you will develop scripts to perform different tasks and a good way to organize your work is through a GitHub repository.  Repositories are free to create (as long as they are < 50 MB) and can serve as a useful place to backup your code.  To start this guide, you will need to have a GitHub.com account already created.\n# \n# ### Create a repository (**repo**)\n# A repository (or repo) can contain any kind of code (python, C++, Fortran, etc), spreadsheets, data files, Jupyter notebooks, and most types of files that you can think of. To create a repository:\n# - In the upper right corner, click + and then select **New Repository**.\n# - Name your repo `hello-world` for this exercise.\n# - Adding a short description is helpful for you (and others) to get a quick idea what the repo contains.\n# - **Public** repos can be seen by anyone on the internet.  Select this option once your repo is ready for the world to see.  **Private** repos allow the creator more control about who is able to view the repo, where users are allowed access one-by-one.\n# - Select **Initialize this repository with a README**.  Since your repos will likely be private, there is no need to add a license.  A license tells others what they may or *may not* do with your public work.  Academic researchers use a Creative Commons (CC) or MIT License that allow for pretty broad usage, where scientists within industry are more selective.\n# - Click **Create repository**.\n# \n# ### Create a Branch\n# Branching is the way to work on experimental parts of your repo.  By default your repo has a new branch named *main*, which is what each branch eventually converges to. To create a new branch:\n# \n# - Go to your repo `hello-world`\n# - Click the drop down that says **branch:main**.\n# - Type a branch name, `readme-edits`, into the new branch text box.\n# - Select the blue **Create branch** box.\n# \n# Now you have two branches, `main` and `readme-edits`.  These two branches are identical right now, but the changes you make to the `readme-edits` branch will not directly affect the `main` branch.\n# \n# ### Make and commit changes\n# \n# After creating your *readme-edits* branch, you should now be on the code-view for that branch.  Let's make some edits and see what happens.  Saved changes on GitHub are called commits.  Each commit also contains a description explaining why a particular change was made.  This is particurly useful for developing code over large periods of time or within groups.  Let's make some changes to the **README.md** file and commit those to the repo:\n# - Click the **README.md** file.\n# - Click the pencil icon in the upper right corner to edit.\n# - In the editor, write a bit about yourself.  What are your research interests?\n# - Write a commite message that describes your changes (e.g., \"I'm super awesome because I can make changes to my very own GitHub repo!\")\n# - Click the **Commit changes** button.\n# \n# The changes are now saved to the `readme-edits` branch, so now this branch is different than the `main` branch*.\n# \n# ### Open a Pull Request\n# \n# A pull request is a way for you (and others) to suggest changes to the *main* branch.  Since you made changes to the `readme-edits` branch, you can now issue a `pull request`.  A pull request will show the differences between both branches.  The changes, addition, and subtraction are shown in green and red.  In this process, you can also use the @mention system with other GitHub users to have discussions about the pull request and receive feedback.  Now we'll open a pull request so that you can see how to review changes (although you may not do this as often for your own repos).\n# \n# - Click the **Pull Request** tab, then click the green **New pull request** button.\n# - In the **Example Comparisons** box, select the `readme-edits` branch to compare with `main`.\n# - Look over the changes between branches and make sure they are what you want. Then click the green **Create Pull Request** button.\n# - Give your pull request a title and write a brief description of your changes.  Logging the changes in your edits will make it easier to diagnose problems later.\n# - Click **Create pull request**!\n# \n# ### Merge your Pull Request\n# \n# In the previous 2 sections, you made a new branch of `hello-world`, edited the branch, and submitted a pull request.  The final step is to bring the changes to the `main` branch.  To merge your `readme-edits` branch into `main`:\n# \n# - Click the green **Marge pull request** button to merge the changes into `main`.\n# - Click **Confirm merge**.\n# - Delete the `readme-edits` branch, since its changes have been incorporated with the **Delete branch** button in the purple box.\n# \n# ### GitHub Desktop\n# \n# The above guide can be used to create a repository through the web interface of GitHub.  When working with your own repos, it is a little easier to use **GitHub Desktop**, which is a desktop application that simplifies pushing changes to the `main` branch.  This requires a software install, which can be found [here](https://desktop.github.com/).  After installing the software, your can:\n# \n# - Clone your repository to your local path (File --> Clone repository).\n# - Open your repo from your local path and edit your files. \n# - After saving your files in the local path, the changes will appear in GitHub Desktop (simliar to a pull request).\n# - Add a description of the changes and click commit to the *main* branch (blue button)\n# - Click the **Push origin** button (update all your changes back to the web version of GitHub)\n# \n\n# ## LaTex (Preparing your work)\n# \n# In the past, scientists had to learn two skills: scientific inquiry and typesetting.  However, mathematicians developed a typesetting software, LaTex, that was more programattic, which made it easier to typeset equations within a document.  In this course, you will need to communicate your results to others (especially your instructor), where you will use LaTex.  To make it easier, we will use the online platform **Overleaf**.  Similar to the guide for GitHub, it is assumed that you have successfully created an Overleaf account.  Note that Overleaf provides its own guides that can be found [here](https://www.overleaf.com/learn/how-to/Creating_a_document_in_Overleaf).\n# \n# ### Creating a project\n# \n# Creating a project in Overleaf can be accomplished in **two** ways: 1) start a project from scratch or 2) start a project from a template.  To start a project from scratch:\n# \n# - Click the green **New Project** button\n# - Select **Blank Project**\n# - Name your project\n# - Click **Create** and then the editor will open\n# \n# To start a project from a template:\n# \n# - Click the green **New Project** button\n# - Select **Academic Journal** from the Templates\n# - Find the **RevTex** tag at the bottom (collection of green tags) and Click it\n# - Select the **RevTex 4.2** template from the American Physical Society\n# \n# When preparing your class assignments, you can build your project from scratch so that you can learn more about the LaTex environment.  To submit each of your projects, you will need to build from the **RevTex** template because it will import the default style for a Journal like *Physical Review*.\n# \n# ### Your 1st Document\n# \n# Open the blank project that you created in the previous section.  In this project, we will create a simple working example (look [here](https://www.overleaf.com/learn/latex/Creating_a_document_in_LaTeX)).  A LaTex document contains some *front* matter, a *body*, and some *back* matter.  The front matter tells the LaTex compiler what kind of document you are trying to create, how should the document be formatted *globally*.  The body will have the text, figures, and tables in a manner similar to most word processors.  The back matter will tell the LaTex compiler how to format references or setup an Appendix.\n# \n# Here's a simple working example: \n# \n# >\\documentclass{article}\n# \n# >\\begin{document}\n# \n# >First document. This is a simple example, with no extra parameters or packages included.\n# \n# >\\end{document}\n# \n# This example will create an **article** document, adds the text, and compiles it as a *pdf* file in the right window.\n# \n# ### The Front Matter\n# \n# The *front* matter is everything before the *>\\begin{document}* line.  Here, we will replace the *\\documentclass{article}* with the following:\n# \n# >\\documentclass[12pt, letterpaper]{article}\n# \n# >\\usepackage[margin=1.0in]{geometry}\n# \n# >\\usepackage[utf8]{inputenc}\n# >\n# >\\title{First document}\n# \n# >\\author{Your Name \\thanks{funded by the Overleaf team}}\n# \n# >\\date{\\today}\n# \n# Here's an explanation of what we just added:\n# \n# >\\documentclass[12pt, letterpaper]{article}\n# \n# \n# This defines the type of document with some additional parameters inside brackets that are comma-separated can be passed to the command. The extra parameters set the font size (12pt) and the paper size (letterpaper). Note that Overleaf uses a European LaTeX distribution, which produces documents in A4 size by default, so letterpaper is important.  Another important parameter that can be passed to the \\documentclass command is twocolumn if you want your text in a two-column format and twoside for two-side paper sheet printing. \n# \n# \n# >\\usepackage[margin=1.0in]{geometry}\n# \n# \n# This defines the page margins.  Everything you submit should have 1 inch margins.  More detail about paper size, orientation, and margins can be found [here](https://www.overleaf.com/learn/latex/Page_size_and_margins)\n# \n# >\\usepackage[utf8]{inputenc}\n# \n# \n# This is the encoding for the document to allow special characters beyond ASCII to be used in the text. It can be omitted or changed to another encoding but utf-8 is recommended. \n# \n# The next three lines are self-descriptive.  But you will need the *\\maketitle* **after** the \\begin{document} for those items to appear.\n# \n# ### The Body\n# \n# The body is similar to what you would find in a normal word processor.  The first element to add to the body is the *abstract*.  An abstract informs the reader what will follow in the rest of the document.  For your class projects, this will be a <250 word summary of your work.  In your class assignments, you can write a summary of what you learned so that when *future* you comes back to it, it will hopefully make sense.  To create an abstract:\n# \n# >\\begin{abstract}\n# \n# >This is a simple paragraph at the beginning of the document. A brief introduction to the main subject.\n# \n# >\\end{abstract}\n# \n# you must create an abstract environment.  Environments (e.g., abstract, figure, table, equation) always have a \\begin and an \\end statement to tell the LaTex compiler that it needs to do something different here and for how long.\n# \n# There are other elements that in the body that **don't** need an environment because they are self explanatory to the compiler when to stop.  For example, you can organize the body using sections, subsections, subsubsections, etc.  Although an environment is not required, you do need a `\\` to tell the compiler that it isn't really text either.\n# \n# >\\section{Introduction}\n# \n# >\\section{Methods}\n# \n# >\\subsection{Newton's 1st Law}\n# \n# >\\subsubsection{Einstein's Theory of General Relativity}\n# \n# >\\section{Results}\n# \n# In the above examples:\n# \n# - The first section is the Introduction and it will be enumerated starting from 1.  The LaTex compiler will know when the Introduction ends when it encounters the next \\section command.\n# - The second section called Methods (enumerated with 2) has a subsection called Newton's 1st Law.  Subsections are then enumerated with a \".#\", where the above subsection is 2.1. Subsubsections will gain an additional \".#\" so that it will numbered 2.1.1. \n# - The third section (enumerated with 3) tells the compiler to go back to the previous level in the tree.\n# \n# Between section commands, this is where the main text will appear. In contrast to a word processor (like Word), LaTex allows for inline commands.  The most common inline commands are:\n# \n# - Enter math mode with \\$ signs.  Suppose you need the greek letter $\\alpha$, then you can easily add it to your text by placing the \\alpha between \\$ \\$.  This is less cumbersome than having to define a macro in Word.  Anything that you could do in an equation, can be done in math mode (e.g., \\frac{1}{2}x^2 in between \\$ signs appears as $\\frac{1}{2}x^2$)\n# - Cite a reference.  This will be explained more later.\n# - Add a comment to the writer using \\%.  Everything on a line that comes after \\% will not appear in the pdf document, but can serve as a note for later.\n# - You can add text formatting for **bold**, *italics*, or $\\texttt{texttype}$ using: \\textbf, \\textit, or \\texttt.\n# \n# Figures and tables are created using an environment (recall that this means begin and end statements).  For many of the extra features for figures, you will need to add `\\usepackage{graphicx}` to the front matter. Figures and tables have similar structures as you can see in these basic examples:\n# \n# >\\begin{figure}[!h]\n# \n# >\\centering\n# \n# >\\includegraphics[width=\\linewidth]{filename.png}\n# \n# >\\caption{This is the figure caption, which describes basic aspects of the figure to the reader. \\label{fig:Fig1}}\n# \n# >\\end{figure}\n# \n# and\n# \n# >\\begin{table}[!h]\n# \n# >\\centering\n# \n# >\\begin{tabular}{c|c|c}\n# \n# >\\hline\n# \n# >cell11 & cell12 & cell13 \\ \\\n# \n# >cell21 & cell22 & cell23 \\ \\\n# \n# >cell31 & cell32 & cell33 \n# \n# >\\end{tabular}\n# \n# >caption{This is a table caption, which describes the basic apsects of the table or gives the table a title.  \\label{tab:Tab1}}\n# \n# >\\end{table}\n# \n# The figure and table environment have a [] after the begin statement, where positioning arguments are placed (e.g., !=override default, h=here, t=top of page, b=bottom of page).  This is followed by \\centering, which tells the LaTeX compiler to place the figure/table in the center of the page (<------center------->).  The figure environment relies on the `\\includegraphics` command from the graphicx package, which this has a [] for arguments that tell the LaTeX compiler how to scale the figure.  In the above example, the figure is scaled so that the width of the figure spans an entire line.  The {} after \\includegraphics holds the filename of the image (e.g., `filename.png`), where LaTex can handle many filetypes (e.g., png, jpg, and pdf are the most common).  The table environment is different in that it holds *tabular* environment within *table* environment.  The tabular environment has arguments {} that tell the LateX compiler: \n# \n# - the number of columns (implicitly),\n# - the alignment within columns (explicitly), and\n# - the borders between columns. \n# \n# The columns can be left (l), center (c), or (r) aligned, where the total number of these characters indicates the number of columns (3l's = 3 columns left aligned).  The \\hline command draws a horizontal line that spans the width of the table.  The data within the table is separated using the `&` symbol and a row is terminated with `\\\\`.  The last row **doesn't** need to be terminated with `\\\\` and the `\\end{tabular}` must follow on the next line.\n# \n# Both figures and tables use the *caption* environment to hold the description and a *label* environment so that the figure/table can be dynamically referenced in the text (using `\\ref{fig:Fig1}` or `\\ref{tab:Tab1}`).  The beauty of LaTex is that the referencing system keeps track of the figure and table numbering so that if the order of tables are switched, then the numbering is updated with the next compilation.  Finally, both figures and tables **require** an \\end statement.\n# \n# The LaTex compiler will abort or crash if a given environment does not have matching {} or begin/end statements.  This is usually indicated in the compilation log (upper right button **View Logs**).\n# \n# ### The Back Matter\n# \n# The back matter contains supplementary information to the body (e.g., acknowledgments, references, appendices).  The acknowledgments (**note the spelling**) is an environment so it needs a \\begin{acknowledgments} and an \\end{ackowledgments}, where this section is where you would thank particular individuals/institutions that aided in the completion of the project (e.g., converstations, resources, proofing).  \n# \n# An appendix is started with the `\\appendix` command, which behaves much like the body but includes supplementary material (e.g., a derivation of an equation, how a new method was verified) and it's labeled with letters (A,B,C,...).  For you, this is where you can put the code that you generate using the \\verbatim environment.  Addtional guides on how to include code in Latex can be found [here](https://www.overleaf.com/learn/latex/Code_listing).\n# \n# In addition to the ease of generating equations, LaTex is preferred because it makes referencing easier too with BibTex.  At the end of your document, references are included by telling LaTex the referencing style (e.g., apsrev4-2.bst for *Physical Review*) and a database of references (e.g., references.bib) through supplemental files.  You must include the following for the references:\n# \n# >\\bibliographystyle{style_filename.bst}\n# \n# >\\bibliography{reference_filename.bib}\n# \n# The reference database (*.bib file) will contain entries like the following:\n# \n# ```\n# @ARTICLE{Berman1983,\n#    author       = \"Berman, Jr., G. P. and Izrailev, Jr., F. M.\",\n#    title        = \"Stability of nonlinear modes\",\n#    journal      = \"Physica D\",\n#    volume       = \"88\", \n#    pages        = \"445\",\n#    year         = \"1983\",\n# }\n# ```\n# where the `Berman1983` is a label used for the inline citation command within the body (e.g., \\cite{Berman1983}).  The quotation marks for each field tell BibTex not to change the formatting (i.e., captialization).  There are different types of environments that correspond to different references (e.g., ARTICLE, BOOK, INPROCEEDINGS, etc.).  Remember that environments require an opening { and closing }.\n# \n# The inline citations have more variations within Astronomy because that community uses the author (year) referencing style, while Physical review uses a [number] style.  In this course, you will use the latter.\n\n# ## Problems\n# - Complete the following problems in a Jupyter notebook, where you will save your results as an external file (*.png).\n# - Create a LaTex document with:\n#     - an abstract summary\n#     - sections for each problem that state the problem, summarize what you did, and display the results\n#     - include a reference for each solution (this can be textbooks)\n# \n# 1. Graph both of the following functions on a single figure, with a usefully sized scale.\n# \n#     a. $x^4e^{-2x}$\n#     \n#     b. $[x^2e^{-x}\\sin(x^2)]^2$\n# 2. The file Ba137.txt contains two columns. The first is counts from a Geiger counter, and the second is time in seconds.\n# \n#     a. Make a useful graph of this data.\n#     \n#     b. If this data follows an exponential curve, then plotting the natural log of the data (or plotting the raw data on a logrithmic scale) will result in a straight line. Determine whether this is the case, and explain your conclusion with an appropriate graph.\n# 3. The data in the file Ba137.txt is actual data from a radioactive decay experiment; the first column is the number of decays $N$, the second is the time $t$ in seconds. We'd like to know the half-life $t_{1/2}$ of $^{137}$Ba. It should follow the decay equation\n# $N = N_oe^{-\\lambda t}$\n# where $\\lambda = \\log(2)/\\log(t_{1/2})$. Using the techniques you've learned in this notebook, load the data from file Ba137.txt into appropriately-named variables. Experiment with different values of $N_o$ and $\\lambda$ to create a plot of the resulting equation on top of the data. What is your best estimate for $t_{1/2}$?\n# 4. The normal modes and angular frequencies of those modes for a linear system of four coupled oscillators of mass m, separated by springs of equal strength k, are given by the eigenvectors and eigenvalues of M, shown below.  Find the eigenfrequencies (Try [linalg.eig](https://numpy.org/doc/stable/reference/generated/numpy.linalg.eig.html#numpy.linalg.eig) from numpy).\n# \n#     ![Coupled_Oscillator](Coupled_Oscillator_matrix.png)\n# 5. Create a single plot that shows separate graphs of position, velocity, and acceleration for an object in free-fall. Your plot should have a single horizontal time axis and separate stacked graphs showing position, velocity, and acceleration each on their own vertical axis. The online matplotlib gallery will probably be helpful! Print the graph, with your name in the title.\n", "meta": {"hexsha": "fb330716d007bad618fdc9ff326d080020599c09", "size": 36452, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/courseware/Chapter_1/Gentle_Introduction.py", "max_stars_repo_name": "saturnaxis/PHYS3820_Book", "max_stars_repo_head_hexsha": "e6ead8c5353c7cfacba58376d259f6c3a11b0b3a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_build/jupyter_execute/courseware/Chapter_1/Gentle_Introduction.py", "max_issues_repo_name": "saturnaxis/PHYS3820_Book", "max_issues_repo_head_hexsha": "e6ead8c5353c7cfacba58376d259f6c3a11b0b3a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/courseware/Chapter_1/Gentle_Introduction.py", "max_forks_repo_name": "saturnaxis/PHYS3820_Book", "max_forks_repo_head_hexsha": "e6ead8c5353c7cfacba58376d259f6c3a11b0b3a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-17T23:19:38.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-17T23:19:38.000Z", "avg_line_length": 69.4323809524, "max_line_length": 946, "alphanum_fraction": 0.7368319982, "include": true, "reason": "import numpy,from numpy", "num_tokens": 9104, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.34864514886966624, "lm_q2_score": 0.2200070997458932, "lm_q1q2_score": 0.07670440804329044}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.5'\n#       jupytext_version: 1.11.3\n#   kernelspec:\n#     display_name: Python 3\n#     name: python3\n# ---\n\n# + [markdown] id=\"view-in-github\" colab_type=\"text\"\n# <a href=\"https://colab.research.google.com/github/probml/pyprobml/blob/master/book2/rl/rl_demos.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n\n# + [markdown] id=\"POrA585UFLms\"\n#\n#\n# ![GitHub](https://img.shields.io/github/license/probml/pyprobml)\n#\n# Colab authors: Kevin P. Murphy (murphyk@gmail.com) and Mahmoud Soliman (mjs@aucegypt.edu)\n#\n#\n\n# + id=\"I3CEU8u0FQR0\"\n# Attribution \n# This notebook is based on the following: \n# https://github.com/mjsML/VizDoom-Keras-RL\n# https://colab.research.google.com/github/keras-team/keras-io/blob/master/examples/rl/ipynb/actor_critic_cartpole.ipynb\n\n# + id=\"qEYlbLuzFh_b\" colab={\"base_uri\": \"https://localhost:8080/\"} outputId=\"b0661fbe-0e44-4a7a-ae7b-d5c081893257\"\n# Imports\nfrom tensorflow.python.client import device_lib\nfrom psutil import virtual_memory\nimport cv2\nfrom google.colab.patches import cv2_imshow\n# %tensorflow_version 2.x\nimport tensorflow as tf\nimport os\n\n\nfrom sklearn.neighbors import KNeighborsClassifier as KNN\nfrom sklearn.model_selection import cross_val_score\n\n\nfrom sklearn.datasets.samples_generator import make_blobs\nfrom  IPython import display\nfrom matplotlib import pyplot as plt\n\nimport numpy as np\n\nimport pathlib\nimport shutil\nimport tempfile\n\nfrom tqdm import tqdm\n\n# + id=\"X_8KoI6UFkRo\" colab={\"base_uri\": \"https://localhost:8080/\"} outputId=\"0055b9e3-d953-4304-830f-ad9fdd54c2e0\"\n#title Hardware check \n\n\n\ndef find_accelerator():\n  \n  mem = virtual_memory()\n  devices=device_lib.list_local_devices()\n  RAM=\"Physical RAM: {:.2f} GB\".format(mem.total/(1024*1024*1024))\n  try:\n    tpu = tf.distribute.cluster_resolver.TPUClusterResolver()  \n    device=[\"TPU at \"+str(tpu.cluster_spec().as_dict()['worker'])]  \n  except ValueError:\n    device =[d.physical_device_desc for d in devices if d.device_type==\"GPU\"]\n  if not device:\n    return None, RAM\n  return device ,  RAM \n\na,r=find_accelerator()\nprint(\"Please make sure that the statement below says Accelerator found\")\nprint(\"Accelerator found:\",a,r)\n\n\n\n# + id=\"w3V-stpMFlJN\" colab={\"base_uri\": \"https://localhost:8080/\"} outputId=\"5f55dbeb-d950-4b08-b707-018a03c05f3a\"\n#title Install the extra required packages if any\n# Installation of libs as per \n# https://stackoverflow.com/questions/50667565/how-to-install-vizdoom-using-google-colab\n\n# %%bash\n# Install deps from \n# https://github.com/mwydmuch/ViZDoom/blob/master/doc/Building.md#-linux\n\napt-get install build-essential zlib1g-dev libsdl2-dev libjpeg-dev \\\nnasm tar libbz2-dev libgtk2.0-dev cmake git libfluidsynth-dev libgme-dev \\\nlibopenal-dev timidity libwildmidi-dev unzip\napt-get install libboost-all-dev\napt-get install liblua5.1-dev\n\n# + [markdown] id=\"M5vmaF61ZvV5\"\n# #Partially observed Markov decision processes (POMDPs) \n# We will start by exploring POMDPs , the states of the environment, $z_{t}$ , are hidden from the agent. The agent gets to see partial observations derived from the hidden state, which we denote by\n# $s_{t} \\in \\mathcal{S}$ these are sampled from the observation model, $p(s_{t}|z_{t})$.\n#\n# In this example we will work with ViZDoom and Deep Recurrent Q Network.\n#\n# Note that this is a quick overview example, the details will be discussed later.\n\n# + [markdown] id=\"JBTCb79f72TU\"\n#  ## Deep Recurrent Q Network\n\n# + id=\"Q0npOg2hPfrF\" colab={\"base_uri\": \"https://localhost:8080/\"} outputId=\"70d73c24-44f4-466b-ed6b-a338474c9b2c\"\n#title Install ViZDoom... takes few mins\n\n# !pip install vizdoom\n\n\n# + id=\"5HSk5mAdPbIv\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 1000} outputId=\"8480df6f-678c-46fd-c051-309b828bc49a\"\n#title Clone ViZDoom-Keras-RL repo and imports\n# Clone VizDoom-Keras-RL\n# !git clone https://github.com/mjsML/VizDoom-Keras-RL.git\n# %cd /content/VizDoom-Keras-RL\nfrom __future__ import print_function\n\nimport skimage as skimage\nfrom skimage import transform, color, exposure\nfrom skimage.viewer import ImageViewer\nimport random\nfrom random import choice\nimport numpy as np\nfrom collections import deque\nimport time\n\nimport json\nfrom keras.models import model_from_json\nfrom keras.models import Sequential, load_model, Model\nfrom keras.layers.wrappers import TimeDistributed\nfrom keras.layers.core import Dense, Dropout, Activation, Flatten, RepeatVector, Masking\nfrom keras.layers import Convolution2D, Dense, Flatten, MaxPooling2D, Input, AveragePooling2D, Lambda, Activation, Embedding\n#tf.keras.layers.Concatenate(axis=1)([x, y])\nfrom keras.layers.recurrent import LSTM, GRU\n#from keras.optimizers import SGD, Adam, rmsprop\nfrom keras.optimizers import SGD, Adam\nfrom keras import backend as K\n\nfrom vizdoom import DoomGame, ScreenResolution\nfrom vizdoom import *\nimport itertools as it\nfrom time import sleep\nimport tensorflow as tf\n\nfrom networks import Networks\n\n\n# + id=\"7Pqux1c-Trj4\"\n#title Setup ViZDoom with defend the center scenario\n\n#TF2 TF1 compatibility \nconfig = tf.compat.v1.ConfigProto()\nconfig.gpu_options.allow_growth = True\nsess = tf.compat.v1.Session(config=config)\ntf.compat.v1.keras.backend.set_session(sess)\n\nfrom drqn import ReplayMemory,DoubleDQNAgent,preprocessImg\n\ngame = DoomGame()\ngame.load_config(\"/content/VizDoom-Keras-RL/defend_the_center.cfg\")\ngame.set_sound_enabled(True)\ngame.set_screen_resolution(ScreenResolution.RES_640X480)\ngame.set_window_visible(False)\ngame.init()\n\ngame.new_episode()\ngame_state = game.get_state()\n\nmisc = game_state.game_variables  # [KILLCOUNT, AMMO, HEALTH]\nprev_misc = misc\n\naction_size = game.get_available_buttons_size()\n\nimg_rows, img_cols = 64, 64\nimg_channels = 3  # Color channel\ntrace_length = 4  # Temporal Dimension\n\nstate_size = (trace_length, img_rows, img_cols, img_channels)\nagent = DoubleDQNAgent(state_size, action_size, trace_length)\n\nagent.model = Networks.drqn(state_size, action_size, agent.learning_rate)\nagent.target_model = Networks.drqn(\n    state_size, action_size, agent.learning_rate)\n\ns_t = game_state.screen_buffer  # 480 x 640\ns_t = preprocessImg(s_t, size=(img_rows, img_cols))\n\nis_terminated = game.is_episode_finished()\n\n# + id=\"KEOjhw2tR1zl\"\n#title Start training DRQN Agent\nepsilon = agent.initial_epsilon\nGAME = 0\nt = 0\nmax_life = 0  # Maximum episode life (Proxy for agent performance)\nlife = 0\nepisode_buf = []  # Save entire episode\n\n# Buffer to compute rolling statistics\nlife_buffer, ammo_buffer, kills_buffer = [], [], []\n\nwhile not game.is_episode_finished():\n\n    loss = 0\n    Q_max = 0\n    r_t = 0\n    a_t = np.zeros([action_size])\n\n    # Epsilon Greedy\n    if len(episode_buf) > agent.trace_length:\n        # 1x8x64x64x3\n        state_series = np.array(\n            [trace[-1] for trace in episode_buf[-agent.trace_length:]])\n        state_series = np.expand_dims(state_series, axis=0)\n        action_idx = agent.get_action(state_series)\n    else:\n        action_idx = random.randrange(agent.action_size)\n    a_t[action_idx] = 1\n\n    a_t = a_t.astype(int)\n    game.set_action(a_t.tolist())\n    skiprate = agent.frame_per_action\n    game.advance_action(skiprate)\n\n    game_state = game.get_state()  # Observe again after we take the action\n    is_terminated = game.is_episode_finished()\n\n    # each frame we get reward of 0.1, so 4 frames will be 0.4\n    r_t = game.get_last_reward()\n\n    if (is_terminated):\n        if (life > max_life):\n            max_life = life\n        GAME += 1\n        life_buffer.append(life)\n        ammo_buffer.append(misc[1])\n        kills_buffer.append(misc[0])\n        print(\"Episode Finish \", misc)\n        game.new_episode()\n        game_state = game.get_state()\n        misc = game_state.game_variables\n        s_t1 = game_state.screen_buffer\n\n    s_t1 = game_state.screen_buffer\n    misc = game_state.game_variables\n    s_t1 = preprocessImg(s_t1, size=(img_rows, img_cols))\n\n    r_t = agent.shape_reward(r_t, misc, prev_misc, t)\n\n    if (is_terminated):\n        life = 0\n    else:\n        life += 1\n\n    # update the cache\n    prev_misc = misc\n\n    # Update epsilon\n    if agent.epsilon > agent.final_epsilon and t > agent.observe:\n        agent.epsilon -= (agent.initial_epsilon -\n                          agent.final_epsilon) / agent.explore\n\n    # Do the training\n    if t > agent.observe:\n        Q_max, loss = agent.train_replay()\n\n    # save the sample <s, a, r, s'> to episode buffer\n    episode_buf.append([s_t, action_idx, r_t, s_t1])\n\n    if (is_terminated):\n        agent.memory.add(episode_buf)\n        episode_buf = []  # Reset Episode Buf\n\n    s_t = s_t1\n    t += 1\n\n    # save progress every 10000 iterations\n    if t % 10000 == 0:\n        print(\"Now we save model\")\n        agent.model.save_weights(\"./models/drqn.h5\", overwrite=True)\n\n    # print info\n    state = \"\"\n    if t <= agent.observe:\n        state = \"observe\"\n    elif t > agent.observe and t <= agent.observe + agent.explore:\n        state = \"explore\"\n    else:\n        state = \"train\"\n\n    if (is_terminated):\n        print(\"TIME\", t, \"/ GAME\", GAME, \"/ STATE\", state,\n              \"/ EPSILON\", agent.epsilon, \"/ ACTION\", action_idx, \"/ REWARD\", r_t,\n              \"/ Q_MAX %e\" % np.max(Q_max), \"/ LIFE\", max_life, \"/ LOSS\", loss)\n\n        # Save Agent's Performance Statistics\n        if GAME % agent.stats_window_size == 0 and t > agent.observe:\n            print(\"Update Rolling Statistics\")\n            agent.mavg_score.append(np.mean(np.array(life_buffer)))\n            agent.var_score.append(np.var(np.array(life_buffer)))\n            agent.mavg_ammo_left.append(np.mean(np.array(ammo_buffer)))\n            agent.mavg_kill_counts.append(np.mean(np.array(kills_buffer)))\n\n            # Reset rolling stats buffer\n            life_buffer, ammo_buffer, kills_buffer = [], [], []\n\n            # Write Rolling Statistics to file\n            with open(\"statistics/drqn_stats.txt\", \"w\") as stats_file:\n                stats_file.write('Game: ' + str(GAME) + '\\n')\n                stats_file.write('Max Score: ' + str(max_life) + '\\n')\n                stats_file.write('mavg_score: ' +\n                                  str(agent.mavg_score) + '\\n')\n                stats_file.write(\n                    'var_score: ' + str(agent.var_score) + '\\n')\n                stats_file.write('mavg_ammo_left: ' +\n                                  str(agent.mavg_ammo_left) + '\\n')\n                stats_file.write('mavg_kill_counts: ' +\n                                  str(agent.mavg_kill_counts) + '\\n')\n\n\n# + [markdown] id=\"EFHwTMtjtrpI\"\n# # Fully observed Markov decision processes (MDPs)\n# Now we explore fully observed Markov decision process.\n#\n# In a fully observable problem the observed state is equal to the hidden state (i.e., $s_{t}=z_{t}$). \n#\n# In this case, the POMDP reduces to a simpler model known as a Markov decision process or MDP\n#\n\n# + [markdown] id=\"PnFH2ojv7X6i\"\n#\n# ## Actor Critic Method\n# As an agent takes actions and moves through an environment, it learns to map the observed state of the environment to two possible outputs:\n#\n# **Recommended action:** \n#\n# A probabiltiy value for each action in the action space. The part of the agent responsible for this output is called the actor.\n#\n#\n# **Estimated rewards in the future:** \n#\n# Sum of all rewards it expects to receive in the future. The part of the agent responsible for this output is the critic.\n#\n# Agent and Critic learn to perform their tasks, such that the recommended actions from the actor maximize the rewards.\n#\n#\n# **CartPole-V0**\n#\n# A pole is attached to a cart placed on a frictionless track. The agent has to apply force to move the cart. It is rewarded for every time step the pole remains upright. The agent, therefore, must learn to keep the pole from falling over.\n\n# + id=\"6UfvC4ni0Zan\"\n#@title Imports\nimport gym\nimport numpy as np\nimport tensorflow as tf\nfrom tensorflow import keras\nfrom tensorflow.keras import layers\n\n# Configuration parameters for the whole setup\nseed = 42\ngamma = 0.99  # Discount factor for past rewards\nmax_steps_per_episode = 10000\nenv = gym.make(\"CartPole-v0\")  # Create the environment\nenv.seed(seed)\neps = np.finfo(np.float32).eps.item()  # Smallest number such that 1.0 + eps != 1.0\n\n# + id=\"ay_fSFKW0oxp\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 223} outputId=\"ff37bd81-65b4-4a63-91c5-c17ef635107a\"\n#@title Define Model\nnum_inputs = 4\nnum_actions = 2\nnum_hidden = 128\n\ninputs = layers.Input(shape=(num_inputs,))\ncommon = layers.Dense(num_hidden, activation=\"relu\")(inputs)\naction = layers.Dense(num_actions, activation=\"softmax\")(common)\ncritic = layers.Dense(1)(common)\n\nmodel = keras.Model(inputs=inputs, outputs=[action, critic])\n\n# + id=\"uHyJ3w6n6Fdn\" cellView=\"form\"\n#@title Train model\noptimizer = keras.optimizers.Adam(learning_rate=0.01)\nhuber_loss = keras.losses.Huber()\naction_probs_history = []\ncritic_value_history = []\nrewards_history = []\nrunning_reward = 0\nepisode_count = 0\n\nwhile True:  # Run until solved\n    state = env.reset()\n    episode_reward = 0\n    with tf.GradientTape() as tape:\n        for timestep in range(1, max_steps_per_episode):\n            # env.render(); Adding this line would show the attempts\n            # of the agent in a pop up window.\n\n            state = tf.convert_to_tensor(state)\n            state = tf.expand_dims(state, 0)\n\n            # Predict action probabilities and estimated future rewards\n            # from environment state\n            action_probs, critic_value = model(state)\n            critic_value_history.append(critic_value[0, 0])\n\n            # Sample action from action probability distribution\n            action = np.random.choice(num_actions, p=np.squeeze(action_probs))\n            action_probs_history.append(tf.math.log(action_probs[0, action]))\n\n            # Apply the sampled action in our environment\n            state, reward, done, _ = env.step(action)\n            rewards_history.append(reward)\n            episode_reward += reward\n\n            if done:\n                break\n\n        # Update running reward to check condition for solving\n        running_reward = 0.05 * episode_reward + (1 - 0.05) * running_reward\n\n        # Calculate expected value from rewards\n        # - At each timestep what was the total reward received after that timestep\n        # - Rewards in the past are discounted by multiplying them with gamma\n        # - These are the labels for our critic\n        returns = []\n        discounted_sum = 0\n        for r in rewards_history[::-1]:\n            discounted_sum = r + gamma * discounted_sum\n            returns.insert(0, discounted_sum)\n\n        # Normalize\n        returns = np.array(returns)\n        returns = (returns - np.mean(returns)) / (np.std(returns) + eps)\n        returns = returns.tolist()\n\n        # Calculating loss values to update our network\n        history = zip(action_probs_history, critic_value_history, returns)\n        actor_losses = []\n        critic_losses = []\n        for log_prob, value, ret in history:\n            # At this point in history, the critic estimated that we would get a\n            # total reward = `value` in the future. We took an action with log probability\n            # of `log_prob` and ended up recieving a total reward = `ret`.\n            # The actor must be updated so that it predicts an action that leads to\n            # high rewards (compared to critic's estimate) with high probability.\n            diff = ret - value\n            actor_losses.append(-log_prob * diff)  # actor loss\n\n            # The critic must be updated so that it predicts a better estimate of\n            # the future rewards.\n            critic_losses.append(\n                huber_loss(tf.expand_dims(value, 0), tf.expand_dims(ret, 0))\n            )\n\n        # Backpropagation\n        loss_value = sum(actor_losses) + sum(critic_losses)\n        grads = tape.gradient(loss_value, model.trainable_variables)\n        optimizer.apply_gradients(zip(grads, model.trainable_variables))\n\n        # Clear the loss and reward history\n        action_probs_history.clear()\n        critic_value_history.clear()\n        rewards_history.clear()\n\n    # Log details\n    episode_count += 1\n    if episode_count % 10 == 0:\n        template = \"running reward: {:.2f} at episode {}\"\n        print(template.format(running_reward, episode_count))\n\n    if running_reward > 195:  # Condition to consider the task solved\n        print(\"Solved at episode {}!\".format(episode_count))\n        break\n\n\n# + [markdown] id=\"H0hXYOtJ6NbJ\"\n# ### Visualizations\n#\n#\n# In early stages of training:\n#\n#\n# ![Imgur](https://i.imgur.com/5gCs5kH.gif)\n#\n#\n# In later stages of training:\n#\n#\n# ![Imgur](https://i.imgur.com/5ziiZUD.gif)\n", "meta": {"hexsha": "bb55659da7bd8c6d1013a8e7170fc2282eb5f0e7", "size": 16821, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks-text-format/rl_demos.py", "max_stars_repo_name": "arpitvaghela/probml-notebooks", "max_stars_repo_head_hexsha": "32ecb309dd474b989fd1c6ce4ad6dab7a25bbead", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 166, "max_stars_repo_stars_event_min_datetime": "2021-07-16T17:33:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T03:35:34.000Z", "max_issues_repo_path": "notebooks-text-format/rl_demos.py", "max_issues_repo_name": "arpitvaghela/probml-notebooks", "max_issues_repo_head_hexsha": "32ecb309dd474b989fd1c6ce4ad6dab7a25bbead", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 29, "max_issues_repo_issues_event_min_datetime": "2021-07-21T16:31:51.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T19:50:13.000Z", "max_forks_repo_path": "notebooks-text-format/rl_demos.py", "max_forks_repo_name": "arpitvaghela/probml-notebooks", "max_forks_repo_head_hexsha": "32ecb309dd474b989fd1c6ce4ad6dab7a25bbead", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 48, "max_forks_repo_forks_event_min_datetime": "2021-07-17T08:26:18.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T03:36:18.000Z", "avg_line_length": 33.9133064516, "max_line_length": 239, "alphanum_fraction": 0.6881873848, "include": true, "reason": "import numpy", "num_tokens": 4366, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4416729909662417, "lm_q2_score": 0.17328821233352104, "lm_q1q2_score": 0.0765367230405394}}
{"text": "#!/usr/bin/python\n# -*- coding: utf-8 -*-\n\n\n\n#                                      \n#  Roulette - Klasse  von zufall           \n#                                                 \n                                  \n#\n#  This file is part of zufall\n#\n#\n#  Copyright (c) 2019 Holger Böttcher  hbomat@posteo.de\n#\n#\n#  Licensed under the Apache License, Version 2.0 (the \"License\")\n#  you may not use this file except in compliance with the License\n#  You may obtain a copy of the License at\n#  \n#      http://www.apache.org/licenses/LICENSE-2.0\n# \n#  Unless required by applicable law or agreed to in writing, software\n#  distributed under the License is distributed on an \"AS IS\" BASIS\n#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n#  See the License for the specific language governing permissions and\n#  limitations under the License.\n#  \n\n\n\nimport matplotlib.pyplot as plt\nimport matplotlib.patches as patches\n\nfrom sympy import Rational, Integer, nsimplify\nfrom sympy.core.compatibility import iterable\nfrom sympy.printing.latex import latex\n\nfrom zufall.lib.objekte.basis import ZufallsObjekt\nfrom zufall.lib.objekte.gleich_verteilung import GleichVerteilung\nfrom zufall.lib.objekte.datenreihe import DatenReihe\nfrom zufall.lib.funktionen.graf_funktionen import verlauf as verlauf_grafik\n\nfrom zufall.lib.objekte.ausnahmen import ZufallError\n\n\n\n# Roulette - Klasse  \n# -----------------\n\t\nclass Roulette(ZufallsObjekt):                                      \n    \"\"\"\n\t\nRoulette - Spiel\n\t\n**Erzeugung** \n\n   Roulette( ) \n   \t\t \n    \"\"\"\t\t\t\n\t\t\t\n    def __new__(cls, *args, **kwargs):  \n\t\t\t\n        if kwargs.get(\"h\") in (1, 2, 3, 4):                         \n            roulette_hilfe(kwargs[\"h\"])\t\t\n            return\n  \n        cls.colonne1     = {1,4,7,10,13,16,19,22,25,28,31,34} \n        cls.colonne2     = {2,5,8,11,14,17,20,23,26,29,32,35} \t\t\t \n        cls.colonne3     = {3,6,9,12,15,18,21,24,27,30,33,36}\t\t\t\n        cls.douze_premier = set(range(1, 13))\t\t\t \n        cls.douze_milieu  = set(range(13, 25))\t\t\t\n        cls.douze_dernier = set(range(25, 37))\t\t\t \n        cls.pair         = set(range(2, 37, 2))          \n        cls.impair       = set(range(1, 36, 2))\t\t\t\n        cls.rouge        = {1,3,5,7,9,12,14,16,18,19,21,23,25,27,30,32,34,36}\t\t\t\n        cls.noir         = set(range(1, 37)).difference(cls.rouge)\t\t\n        cls.manque       = set(range(1, 19))\t\t\t\n        cls.passe        = set(range(19, 37))\t\t\t\n\t\t\n        return ZufallsObjekt.__new__(cls)\n\t\t\t\t\t\n\t\t\t\n    def __str__(self):  \n        return \"Roulette\"\n\t\t\n\t\t\n\t\t\n# Eigenschaften + Methoden\n# ------------------------\n\n    @property\n    def omega(self):\n        \"\"\"Ergebnismenge\"\"\"\t\n        return set(range(37))\n\t\t\n    @property\n    def regeln(self):\n        \"\"\"Regeln für Roulettespiel\"\"\"\t\n\t\t\n        print(\"\\nRoulette - Glücksspiel\\n\")\n        print(\"Eine Kugel wird in eine sich drehende Scheibe geworfen. Sie landet in \") \n        print(\"einem der Felder 0 bis 36, die auf der Scheibe in bunter Reihenfolge\")\n        print(\"angeordnet sind (Gewinnfeld)\\n\")\n        print(\"Auf dem Spielbrett setzt man Spielmarken (Chips) und gewinnt, wenn die \") \n        print(\"Vorhersage eintrifft, das heißt, wenn das Gewinnfeld durch die getrof-\")\n        print(\"fene Wahl erfaßt wird; zu den Setzmöglichkeiten siehe Hilfeseite\\n\")\n        print(\"Wenn die Vorhersage nicht eintrifft, ist der gesetzte Chip verloren \") \n        print(\"Das entspricht einer Gewinnquote von -1 : 1\\n\")\n        return\t\t\n\t\t\n    @property\n    def brett(self):\n        \"\"\"Spielbrett / -tisch (Abbildung)\"\"\"\t\t\t\n\t\t\n        def pline(x, y):\n            return plt.plot(x, y, color=(0,0,0), lw=0.8)\n\n        def prot(x, y, t):\n            return ax.text(x, y, t, fontsize=9, horizontalalignment='center', \n                  verticalalignment='center', color=(1,0,0), \n                  fontname='Times New Roman')\n\n        def pblack(x, y, t):\n            return ax.text(x, y, t, fontsize=9, horizontalalignment='center', \n                   verticalalignment='center', color=(0,0,0),\n                   fontname='Times New Roman')\n\n        def punt(x, y):\n            ax.text(x, y, '12', fontsize=6, horizontalalignment='center', \n                  verticalalignment='center', color=(0,0,0),\n                   fontname='Times New Roman')\n\n        dx, dy = 1.5, 1.5\n        fig = plt.figure(figsize=(3, 4))\n        ax = fig.add_subplot(1, 1, 1)\n        ax.spines['top'].set_visible(False)\t\t\n        ax.spines['bottom'].set_visible(False)\t\t\n        ax.spines['right'].set_visible(False)\t\t\n        ax.spines['left'].set_visible(False)\t\t\n        ax.set_xticks([])\n        plt.axes().xaxis.set_ticks_position('none')\n        ax.set_yticks([])\n        plt.axes().yaxis.set_ticks_position('none')\n        plt.xlim(0, 10*dx)\n        plt.ylim(-0.1, 15*dy)\n        pline([3*dx, 6*dx, 6*dx, 3*dx, 3*dx], [0, 0, 14*dy, 14*dy, 0])\n        pline([4*dx, 4*dx], [dy, 13*dy])\n        pline([5*dx, 5*dx], [dy, 13*dy])\n        for i in range(1, 14):\n            pline([3*dx, 6*dx], [i*dy, i*dy])\n        pline([0, 0], [2*dy, 12*dy])\n        pline([9*dx, 9*dx], [2*dy, 12*dy])\n        pline([3*dx, 0], [dy, 2*dy])\n        pline([3*dx, 0], [2*dy, 3*dy])\n        pline([6*dx, 9*dx], [dy, 2*dy])\n        pline([6*dx, 9*dx], [2*dy, 3*dy])\n        pline([0, 3*dx], [12*dy, 13*dy])\n        pline([9*dx, 6*dx], [12*dy, 13*dy])\n        pline([0, 9*dx], [5*dy, 5*dy])\n        pline([0, 9*dx], [9*dy, 9*dy])\n        pline([2*dx, 2*dx], [1.35*dy, 2.3*dy])\n        pline([7*dx, 7*dx], [1.35*dy, 2.3*dy])\n        pline([dx, dx], [1.7*dy, 2.65*dy])\n        pline([8*dx, 8*dx], [1.7*dy, 2.65*dy])\n        ax.add_patch(patches.RegularPolygon(\n            (1.7*dx, 3.7*dy), 4, 0.6*dx, color=(0,0,0)))\n        ax.add_patch(patches.RegularPolygon(\n            (7.4*dx, 3.7*dy), 4, 0.6*dx, facecolor=(1,0,0)))\n        ax.text(4.5*dx, 13.4*dy, '0', fontsize=9, horizontalalignment='center', \\\n               verticalalignment='center', color=(0,1,0))\n        prot(3.5*dx, 12.4*dy, '1')\n        pblack(4.5*dx, 12.4*dy, '2')\n        prot(5.5*dx, 12.4*dy, '3')\n        pblack(3.5*dx, 11.4*dy, '4')\n        prot(4.5*dx, 11.4*dy, '5')\n        pblack(5.5*dx, 11.4*dy, '6')\n        prot(3.5*dx, 10.4*dy, '7')\n        pblack(4.5*dx, 10.4*dy, '8')\n        prot(5.5*dx, 10.4*dy, '9')\n        pblack(3.5*dx, 9.4*dy, '10')\n        pblack(4.5*dx, 9.4*dy, '11')\n        prot(5.5*dx, 9.4*dy, '12')\n        pblack(3.5*dx, 8.4*dy, '13')\n        prot(4.5*dx, 8.4*dy, '14')\n        pblack(5.5*dx, 8.4*dy, '15')\n        prot(3.5*dx, 7.4*dy, '16')\n        pblack(4.5*dx, 7.4*dy, '17')\n        prot(5.5*dx, 7.4*dy, '18')\n        prot(3.5*dx, 6.4*dy, '19')\n        pblack(4.5*dx, 6.4*dy, '20')\n        prot(5.5*dx, 6.4*dy, '21')\n        pblack(3.5*dx, 5.4*dy, '22')\n        prot(4.5*dx, 5.4*dy, '23')\n        pblack(5.5*dx, 5.4*dy, '24')\n        prot(3.5*dx, 4.4*dy, '25')\n        pblack(4.5*dx, 4.4*dy, '26')\n        prot(5.5*dx, 4.4*dy, '27')\n        pblack(3.5*dx, 3.4*dy, '28')\n        pblack(4.5*dx, 3.4*dy, '29')\n        prot(5.5*dx, 3.4*dy, '30')\n        pblack(3.5*dx, 2.4*dy, '31')\n        prot(4.5*dx, 2.4*dy, '32')\n        pblack(5.5*dx, 2.4*dy, '33')     \n        prot(3.5*dx, 1.4*dy, '34')\n        pblack(4.5*dx, 1.4*dy, '35')\n        prot(5.5*dx, 1.4*dy, '36')  \n        pblack(0.5*dx, 2.4*dy, 'P')    \n        pblack(8.5*dx, 2.4*dy, 'P')   \n        punt(0.7*dx, 2.13*dy)\n        punt(8.7*dx, 2.13*dy)\n        pblack(1.35*dx, 2.07*dy, 'M')    \n        pblack(7.35*dx, 2.07*dy, 'M')   \n        punt(1.72*dx, 1.85*dy)\n        punt(7.72*dx, 1.85*dy)    \n        pblack(2.45*dx, 1.75*dy, 'D')    \n        pblack(6.45*dx, 1.75*dy, 'D')   \n        punt(2.75*dx, 1.48*dy)\n        punt(6.75*dx, 1.48*dy)   \n        pblack(1.5*dx, 10.5*dy, 'Passe')\n        pblack(7.5*dx, 10.5*dy, 'Manque')\n        pblack(1.5*dx, 7*dy, 'Pair')\n        pblack(7.5*dx, 7*dy, 'Impair')\n       \n        plt.show()\n\n    tisch = brett\n\t\n    @property\n    def formeln(self):\n        \"\"\"Berechnungsformeln\"\"\"\t\n\t\n        def dm(x):\n            return display(Math(x))\t\t\n\t\t\n        print(' ')\t\t\n        dm('\\mathrm{Gewinnerwartung\\;beim\\; Roulette - Spiel}')\n        print(' ')\t\n        dm('\\mathrm{Gewinnerwartung\\; bei\\; einer\\; Setzmöglichkeit\\; (Chance):}')\n        dm('\\\\qquad GewinnQuote \\cdot GewinnWahrscheinlichkeit\\, + \\, (-1) \\cdot VerlustWahrscheinlichkeit')\n        dm('\\\\qquad \\mathrm{(\\,-1 = Verlustquote\\;[gesetzter\\;Chip]\\,)}')\n        dm('\\mathrm{Die\\; Wahrscheinlichkeiten\\; der\\; Chancen\\; werden\\; so\\; berechnet:}')\t\t\n        dm('\\qquad P( Chance ) = (Anzahl\\; der\\; Zahlen\\; in\\; der\\; Chance)\\; / \\;37')\t\n        print(' ')\t\t\n        dm('\\mathrm{ Erwartung\\; bei\\; den\\; einzelnen\\; Chancen: \\\\qquad (s.a.\\; Hilfeseite)}')\n        dm('\\mathrm{ Chance \\\\qquad\\\\qquad\\;\\; Anzahl \\\\qquad Erwartung \\;\\\\qquad\\\\qquad\\\\quad\t\\, in\\; \\% \\;zum}')\n        dm('\\mathrm{\\\\qquad\\\\qquad\\\\qquad\\\\quad\\, Zahlen\t\\\\qquad\\\\qquad\\\\qquad\\\\qquad\\\\qquad\\\\qquad\tEinsatz}')\t\n        dm('\\mathrm{plein} \\;\\,\\\\qquad\\\\qquad\\\\quad\\\\quad\\\\quad 1 \\\\quad\\\\quad\t35 \\\\cdot \\\\frac{1}{37} - \\\\frac{36}{37} = -\\\\frac{1}{37} \\\\quad\\\\quad -2.7 \\%')\t\t\n        dm('\\mathrm{a\\; cheval} \\;\\\\qquad\\\\qquad\\\\quad\\\\quad 2 \\\\quad\\\\quad\t17 \\\\cdot \\\\frac{2}{37} - \\\\frac{35}{37} = -\\\\frac{1}{37} \\\\quad\\\\quad -2.7 \\%')\t\t\n        dm('\\mathrm{transversale\\; plein} \\\\quad\\\\qquad 3 \\\\quad\\\\quad\t11 \\\\cdot \\\\frac{3}{37} - \\\\frac{34}{37} = -\\\\frac{1}{37} \\\\quad\\\\quad -2.7 \\%')\t\t\n        dm('\\mathrm{carre} \\;\\,\\\\qquad\\\\qquad\\\\quad\\\\quad\\\\quad 4 \\\\quad\\\\quad\t8 \\\\cdot \\\\frac{4}{37} - \\\\frac{33}{37} = -\\\\frac{1}{37} \\;\\,\\\\quad\\\\quad -2.7 \\%')\t\t\n        dm('\\mathrm{transversale\\; simple} \\,\\;\\\\qquad 6 \\\\quad\\\\quad\t5 \\\\cdot \\\\frac{6}{37} - \\\\frac{31}{37} = -\\\\frac{1}{37} \\;\\\\quad\\\\quad -2.7 \\%')\t\t\n        dm('\\mathrm{Kolonne,\\; Dutzend} \\,\\,\\\\qquad 12 \\\\quad\\\\quad\t2 \\\\cdot \\\\frac{12}{37} - \\\\frac{25}{37} = -\\\\frac{1}{37} \\;\\\\quad\\\\quad -2.7 \\%')\t\t\n        dm('\\mathrm{einfache\\; Chancen} \\;\\;\\\\qquad 18 \\\\quad\\\\quad\t1 \\\\cdot \\\\frac{18}{37} - \\\\frac{19}{37} = -\\\\frac{1}{37} \\;\\\\quad\\\\quad -2.7 \\%')\t\t\n        print(' ')\t\t\n\t\t\n\t\t\n    def P(self, *args, **kwargs):\n        \"\"\"Wahrscheinlichkeit eines Ereignisses\"\"\"\n\t\t\n        if kwargs.get('h'):\n            print(\"\\nWahrscheinlichkeit eines Ereignisses\\n\")\n            print(\"Aufruf   r . P( e )\\n\")\t\t                     \n            print(\"                r    Roulette-Objekt\")\n            print(\"                e    Zahl aus {0,...,36} | Menge/Liste/Tupel von Zahlen |\")\n            print(\"                     Chance beim einmaligen Spielen (s. Hilfeseite)\\n\")\n            print(\"  oder   r . P( e, e1 )\\n\")\t\t                     \n            print(\"Bei der Angabe von zwei Ereignissen wird die bedingte Wahrscheinlich-\")\n            print(\"keit P( e | e1 ) berechnet\\n\")\n            print(\"Beispiele\")\n            print(\"r.P( 4 )   r.P( {12} )   r.P( r.colonne1 )\")\n            print(\"r.P( { 28, 29, 30 } )    r.P( [28, 29, 30] )\")   \n            print(\"r.P( 'r.rouge und r.pair' )\") \n            print(\"r.P( 12, r.rouge )   (bedingte Wahrscheinlichkeit)\\n\")\t\t\t\n            return\t\t\t\n\t\t\t\n        if len(args) not in (1, 2):\n            print('zufall: ein oder zwei Ereignisse angeben')\n            return\t\n\n        def teil(x):\n            if isinstance(x, set):\n                return all([y in omega for y in x])\n            else:\n                if x in omega:\n                    return True\n                return False\n\t\t\t   \n        omega = self.omega\t\t\n\t\t\t\t  \n        if len(args) == 1:\n            e = args[0]\n            if e == 0:\n                pp = Rational(1, 37)\t\t\t\n            elif not e:\n                pp = 0\t\t\t\n            elif not iterable(e) and e in omega:\t\t\t\t\t\n                pp = Rational(1, 37)\n            elif iterable(e):\n                if not all([x in omega for x in e]):\n                    print('zufall: Elemente der Ergebnismenge angeben')\n                    return\n                if not len(e) in (1, 2, 3, 4, 6, 12, 18):\t\t\t\t\t\n                    print('zufall: 1,2,3,4 oder 6 Zahlen oder benannte Chance angeben')\n                    return\n                if len(e) == 2:\n                    if not set(e) in _a_cheval:\n                        print('zufall: keine a_cheval-Chance')\n                        return\n                elif len(e) == 3:\n                    if not set(e) in _transversale_plein:\n                        print('zufall: keine transversale_plein-Chance')\n                        return\n                elif len(e) == 4:\n                    if not set(e) in _carre:\n                        print('zufall: keine carre-Chance')\n                        return\n                elif len(e) == 6:\n                    if not set(e) in _transversale_simple:\n                        print('zufall: keine transversale_simple-Chance')\n                        return\n                elif len(e) == 12:\n                     if not set(e) in [self.colonne1, self.colonne2, self.colonne3, self.douze_premier, \\\n\t\t\t\t           self.douze_milieu, self.douze_dernier]:\n                         print('zufall: keine Chance mit 12 Zahlen')\n                         return\n                elif len(e) == 18:\n                     if not set(e) in [self.pair, self.impair, self.rouge, self.noir, self.manque, \\\n                         self.passe]:\n                         print('zufall: keine Chance mit 18 Zahlen')\n                         return\n                pp = Rational(len(e), 37)\t\t\t\t\t\n            elif isinstance(e, str):\n                uu, oo, nn = e.find('und'), e.find('oder'), e.find('nicht')\t\t\t\n                try:\n                    if uu >= 0:\n                        a, b = e[:uu].strip(), e[uu+3:].strip() \t\t\t\t\t  \n                        ia, ib = a.find('.'), b.find('.')\n                        a, b = a[ia+1:], b[ib+1:]\n                        a, b = 'self.' + a, 'self.' + b\t\t\t\t\t\t\n                        a, b = eval(a), eval(b)\n                        if not (teil(a) and teil(b)):\n                            print('zufall: Ereignisse bei Roulette angeben')\n                            return\n                        if isinstance(a, set):\t\t\t\t\t\t\t\n                            if isinstance(b, set):\t\t\t\t\t\t\t\n                                ee = a.intersection(b)\n                            else:\t\t\t\t\t\t\t\t\n                                ee = a.intersection(set([b]))\n                        else:\t\n                            if isinstance(b, set):\t\t\t\t\t\t\t\n                                ee = set([a]).intersection(b)\n                            else:\t\t\t\t\t\t\t\t\n                                ee = set([a]).intersection(set([b]))\t\t\t\t\t\t\n                        pp = Rational(len(ee), 37)\t\t\t\t\t\t\t\t\t\t\t\n                    elif oo > 0:\n                        a, b = e[:oo].strip(), e[oo+3:].strip()\t\t\t\t\t  \n                        ia, ib = a.find('.'), b.find('.')\n                        a, b = a[ia+1:], b[ib+1:]\n                        a, b = 'self.' + a, 'self.' + b\t\t\t\t\t\t\n                        a, b = eval(a), eval(b)\n                        if not (teil(a) and teil(b)):\n                            print('zufall: Ereignisse bei Roulette angeben')\n                            return\n                        if isinstance(a, set):\t\t\t\t\t\t\t\n                            if isinstance(b, set):\t\t\t\t\t\t\t\n                                ee = a.union(b)\n                            else:\t\t\t\t\t\t\t\t\n                                ee = a.union(set([b]))\n                        else:\t\n                            if isinstance(b, set):\n                                ee = set([a]).union(b)\n                            else:\t\t\t\t\t\t\t\t\n                                ee = set([a]).union(set([b]))\t\t\t\t\t\t\n                        pp = Rational(len(ee), 37)\t\t\t\t\t\t\t\t\t\t\t\n                    elif nn >= 0:\n                        a = e[nn+5:].strip()\t\t\t\t  \n                        ia = a.find('.')\n                        a = a[ia+1:]\n                        a = 'self.' + a\t\t\t\t\t\t\n                        a = eval(a)\n                        if not teil(a):\n                            print('zufall: Ereignis bei Roulette angeben')\n                            return\n                        if isinstance(a, set):\t\t\t\t\t\t\t\n                           ee = omega.difference(a)\n                        else:\n                            ee = omega.difference(set([a]))\t\t\t\t\t\t\n                        pp = Rational(len(ee), 37)\t\t\t\t\t\t\t\t\t\t\t\n                    else:\n                        ee = eval(e)\n                        pp = Rational(len(ee), 37)\t\t\t\t\t\t\t\t\t\t\t\n                except:\n                    print('zufall:', 'Ausdruck überprüfen')\n                    return\t\t\t\n            else:\n                print('zufall: Ereignis bei Roulette angeben')\n                return\n\t\t\t\t\t\t\t\n        elif len(args) == 2: \n            e1, e2 = args\t\n            if iterable(e1):\n                e1 = set(e1)\t\t\t\n            if iterable(e2):\n                e2 = set(e2)\n            try:\t\t\t\n                if isinstance(e1, set):\n                    if isinstance(e2, set):\n                        ee = e1.intersection(e2)\n                    else:\n                        ee = e1.intersection(set([e2]))\n                else:\n                    if isinstance(e2, set):\n                        ee = set([e1]).intersection(e2)\n                    else:\n                        ee = set([e1]).intersection(set([e2]))\n                pp1, pp2 = self.P(ee), self.P(e2)\n                pp = nsimplify(pp1 / pp2, rational=True)\n            except:\n                print('zufall: die Angaben bitte überprüfen')\t\n                return\n            \t\t\t\n        return pp\t\n\t\t\n\t\t\n    def spiel(self, *args, **kwargs):\n        \"\"\"Spiel\"\"\"\n\t\t\n        if kwargs.get('h'):\n            print(\"\\nSpiel     ( Roulette )\\n\")\n            print(\"Aufruf    r . spiel( chance /[, m ] )\\n\")\t\t                     \n            print(\"              r        Roulette-Objekt\")\n            print(\"              chance   gesetzte Chance - einzelne Zahl oder Menge von \")\n            print(\"                       1-6 Zahlen aus {0,1,...,36} | r.colonne1 |\") \n            print(\"                       r.colonne2 | r.colonne3 | r.douze_premier |\")\n            print(\"                       r.douze_milieu | r.douze_dernier | r.pair |\") \n            print(\"                       r.impair | r.rouge | r.noir | r.manque |\") \n            print(\"                       r.passe\")\t\t\t\n            print(\"              m        Anzahl Spiele; Standard=1\\n\")\t\t\t\n            print(\"Zusatz   g=ja   Grafik des Gewinn-Verlaufes\")\n            print(\"         m=ja   Grafik des Verlaufes des mittleren Gewinns\")\n            print(\"         d=ja   Bei Angabe von m > 1 Rückgabe einer DatenReihe mit dem\") \n            print(\"                Gewinn/Verlust je Spiel\")\n            print(\"         gd=ja  Gewinnverlauf + DatenReihe\")\n            print(\"         md=ja  Mittlerer Gewinn + DatenReihe\\n\")\n            return\t\t\t\n\n        try:\t  \n            if len(args) not in (1, 2):\n                raise ZufallError(\"ein oder zwei Argumente angeben\")\n            chance = args[0]\t\t\t\n            if not (iterable(chance) or isinstance(chance, (int, Integer))):\n                raise ZufallError(\"einzelne Zahl oder Menge von Zahlen angeben\")\t\t\t\t\t\n            if isinstance(chance, (int, Integer)):\n                if chance not in self.omega:\n                    raise ZufallError(\"Element der Ergebnismenge angeben\")\t\t\t\t\t\n                chance = set([chance])\t\n            else:\n                chance = set(chance)\n                if not all([x in self.omega for x in chance]):\n                    raise ZufallError(\"Element der Ergebnismenge angeben\")\t\t\t\t\t\n                if len(chance) == 1:\n                    if list(chance)[0] not in self.omega:\t\t\t\n                        raise ZufallError(\"keine gültige Chance\")\t\t\t\t\t\n                elif len(chance) == 2:\n                    if chance not in _a_cheval:\t\t\t\n                        raise ZufallError(\"keine gültige a_cheval-Chance\")\t\t\t\t\t\n                elif len(chance) == 3:\n                   if chance not in _transversale_plein:\t\t\t\n                        raise ZufallError(\"keine gültige transversale_plein-Chance\")\t\t\t\t\t\t\t\t\t\t\t\n                elif len(chance) == 4:\n                    if chance not in _carre:\t\t\t\n                        raise ZufallError(\"keine gültige carre-Chance\")\t\t\t\t\t\n                elif len(chance) == 6:\n                    if chance not in _transversale_simple:\t\t\t\n                        raise ZufallError(\"keine gültige transversale_simple-Chance\")\t\t\t\t\t\t\t\t\n                elif len(chance) == 12:\n                    if chance not in [self.colonne1, self.colonne2, self.colonne3,\n                        self.douze_premier, self.douze_milieu, self.douze_dernier]:\t\t\t\n                        raise ZufallError(\"keine gültige Chance\")\t\t\t\t\t\n                elif len(chance) == 18:\n                    if chance not in [self.pair, self.impair, self.rouge, self.noir,\n                        self.manque, self.passe]:\t\t\t\n                        raise ZufallError(\"keine gültige Chance\")\t\t\t\t\t\n                else:\n                    raise ZufallError(\"keine gültige Chance\")\n\t\t\t\t\t\n            m = 1\t\t\t\n            if len(args) == 2:\n                m = args[1]\t\t\t\n                if not (isinstance(m, (int, Integer)) and m > 0):\t\t\t\n                    raise ZufallError(\"für m ganze Zahl > 0 angebem\")\t\t\t\t\t\n\t\t\n        except ZufallError as e:\n            print('zufall:', str(e))\n            return\n\t\t\t\n        def dm(x):\n            return display(Math(x))\n        \t\t\t\n        vv = GleichVerteilung(37)  \n        if len(args) == 1 or len(args) == 2 and m == 1:\t\t\n            erg = vv.versuch - 1   # die Gleichverteilung ist auf {1,2,...,37} definiert\t\n            print(' ')\t\t\t\n            dm('\\mathrm{Gesetzt\\;\\, :\\;\\; }' + latex(chance))\t\t\n            dm('\\mathrm{Ergebnis:\\;\\; }' + str(erg))\n            txt = '\\mathrm{Spiel\\;gewonnen}' if erg in chance else '\\mathrm{Spiel\\;verloren}'\t\t\t\n            dm(txt)\t\t\n            print(' ')\n            return\t\t\t\n        else:\n            gewinn = dict([(1, 35), (2, 17), (3, 11), (4, 8), (6, 5), (12, 2), (18, 1)])\t\t\n            sp = vv.stich_probe(m)\n            sp = [x-1 for x in sp]\t\t\t\n            dr = [ (gewinn[len(chance)] if x in  chance else -1) for x in sp]\n\n            if kwargs.get('g') or kwargs.get('gd'):\n                print(' ')\t\t\t\n                dm('\\\\qquad\\mathrm{Verlauf\\;des\\;Gewinns,\\;aktueller\\;Gewinn}')\t\t\t\n                verlauf_grafik(dr, art='summe', xlabel='Anzahl Spiele')\n            elif kwargs.get('m') or kwargs.get('md'):\t\n                pass\n                print(' ')\t\t\t\n                dm('\\\\qquad\\mathrm{Verlauf\\;des\\; mittleren\\;Spielgewinnes}') \n                dm('\\\\qquad\\mathrm{grün-theoretischer\\; Erwartungswert\\;bei\\;einem\\;Spiel\\; (-1/37)}')\t\t\t\n                verlauf_grafik(dr, art='mittel', vergl=float(-1/37), xlabel='Anzahl Spiele')\n\t\t\t\n            if not kwargs:\t\t\t\n                L = len(dr)\t\t\t\n                G = dr.count(1)\t\n                V = L - G\n                p = float((G-V)/L * 100)\n                print(' ')\t\t\t\n                dm('\\mathrm{Gesetzt\\;\\,\\; :  \\;\\; }' + latex(chance))\t\t\n                dm('\\mathrm{Gewonnen\\;(1):  \\;\\; }' + str(G))\n                dm('\\mathrm{Verloren\\;(-1):\\;\\; }' + str(V))\n                dm('\\mathrm{Gesamt\\;\\\\quad\\\\quad\\,:\\; }' + str(G-V) + '=' + '{0:.2f}'.format(p) + '\\%')\n            if kwargs.get('d') or kwargs.get('gd') or kwargs.get('md'):\t\t\t\n                dm('\\mathrm{Rückgabe\\; einer\\; DatenReihe\\; mit \\;dem\\;Gewinn\\,/\\,Verlust\\;je\\;Spiel}')\n                print(' ')\t\t\t\n                return DatenReihe(dr)\t\t\t\t\n            print(' ')\t\t\t\n            \n\t\t\t\n    @property\t\t\n    def hilfe(self):  \n        \"\"\"Bezeichner der Eigenschaften und Methoden\"\"\"\n        roulette_hilfe(3)\t\n\t\t\n    h = hilfe\t\t\t\t\t\n\t\t\t\n\t\t\n\t\t\n# Benutzerhilfe für Roulette\n# --------------------------\n\ndef roulette_hilfe(h):\n   \n    if h == 1:\n        print(\"h=2 - Erzeugung\")\n        print(\"h=3 - Eigenschaften und Methoden\")\n        print(\"h=4 - Ereignisse\")\n        return\n\t\t   \n    if h == 2:\n        print(\"\"\" \\\n\t\t\nRoulette - Objekt\n\t\nErzeugung    Roulette( )\n\t\t\t\t \nZuweisung    r = Roulette()   (r - freier Bezeichner)\n\t   \"\"\")\n        return \n\t\t\n    if h == 3:   \n        print(\"\"\" \\\n\t\t\nEigenschaften und Methoden (M) für Roulette\n \t\nr.hilfe          Bezeichner der Eigenschaften und Methoden\nr.brett          Spielbrett (Abbildung)\nr.formeln        Berechnungsformeln\nr.omega          Ergebnismenge\nr.P(...)      M  Wahrscheinlichkeiten beim einmaligen Spielen\nr.regeln         Spielregeln\nr.spiel(...)  M  Spiel\nr.tisch          = s.brett\n\nSynonymer Bezeichner\n\nhilfe   h\n\"\"\")\n        return \n\t\t\n    if h == 4:   \n        print(\"\"\" \\\n\t\t\nEreignisse (Setzmöglichkeiten, Chancen) beim einmaligen Roulette-\nSpiel\n\n(Unbenannte) Ereignisse, die über die Menge der Zahlen angegeben \nwerden:\n                                                                   Anzahl   Gewinn-\nName                Beschreibung                                   Zahlen    quote                                   \n                                                                   \nplein               einzelne Zahl               z.B. 3 bzw. {3}         1   35 : 1\na_cheval            zwei angrenzende Zahlen     z.B. {13,16}            2   17 : 1\ntransversale_plein  Querreihe von drei Zahlen   z.B. {28,29,30}         3   11 : 1\ncarre               vier Zahlen, deren Felder   z.B. {14,15,17,18}      4    8 : 1\n                    in einem Punkt zusammensto-  \n                    ßen bzw. die ersten vier \n                    Zahlen \t\t\t\ntransversale_simple zwei benachbarte Querreihen z.B. {7,8 9,10,11,12}   6    5 : 1\n\nKolonne und Dutzend:\nr.colonne1          die linke Reihe             {1,4,7,..,34}          12    2 : 1\nr.colonne2          die mittlere Reihe          {2,5,8,..,35} \t\t\t \nr.colonne3          die rechte Reihe            {3,6,9,..,36}\t\t\t\nr.douze_premier     das erste Dutzend           {1,2,..,12}\t\t\t \nr.douze_milieu      das mittlere Dutzend        {13,14,..,24}\t\t\t\nr.douze_dernier     das letzte Dutzend          {25,26,..,36}\n\t\t\t \nEinfache Chancen:\nr.pair              die geraden Zahlen außer 0  {2,4,6,..,36}          18    1 : 1\nr.impair            die ungeraden Zahlen        {1,3,5,..,35}\t\t\t\nr.rouge             die roten Zahlen            {1,3,7,..36}\t\t\t\nr.noir              die schwarzen Zahlen        {2,4,6,..35}\t\t\t\nr.manque            die erste Hälfte            {1,2,..,18}\t\t\t\nr.passe             die zweite Hälfte           {19,20,..,36}\t\t\t\n\t\"\"\")\n        return \n\n\t\t\n\t\t\n# 'Unbenannte' Chancen außer plein\t\t\n# --------------------------------\t\t\n_a_cheval = [{0, 1}, {0, 2}, {0, 3}, {1, 2}, {2, 3}, {1, 4}, {2, 5}, {4, 5}, {3, 6}, \\\n                  {5, 6}, {4, 7}, {5, 8}, {6, 9}, {7, 8}, {8, 9}, {7, 10}, {8, 11}, {10, 11}, \\\n                  {9, 12}, {11, 12}, {10, 13}, {11, 14}, {12, 15}, {13, 14}, {13, 16}, \\\n                  {14, 15}, {14, 17}, {15, 18}, {16, 17}, {17, 18}, {16, 19}, {17, 20}, \\\n                  {19, 20}, {18, 21}, {19, 22}, {20, 21}, {20, 23}, {22, 23}, {21, 24}, \\\n                  {22, 25}, {23, 24}, {23, 26}, {25, 26}, {24, 27}, {25, 28}, {26, 27}, \\\n                  {26, 29}, {28, 29}, {27, 30}, {28, 31}, {29, 30}, {29, 32}, {30, 33}, \\\n                  {31, 32}, {32, 33}, {31, 34}, {32, 35}, {33, 36}, {34, 35}, {35, 36}]\t\t\n_transversale_plein = [{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}, {13, 14, 15}, \\\n                  {16, 17, 18}, {19, 20, 21}, {22, 23, 24}, {25, 26, 27}, {28, 29, 30}, \\\n                  {31, 32, 33}, {34, 35, 36}]\t\n_carre = [{1, 2, 3, 4}, {1, 2, 4, 5}, {2, 3, 5, 6}, {4, 5, 7, 8}, {5, 6, 8, 9}, \\\n                  {7, 8, 10, 11}, {8, 9, 11, 12}, {10, 11, 13, 14}, {11, 12, 14, 15}, \\\n                  {13, 14, 16, 17}, {14, 15, 17, 18}, {16, 17, 19, 20}, {17, 18, 20, 21}, \n                  {19, 20, 22, 23}, {20, 21, 23, 24}, {22, 23, 25, 26}, {23, 24, 26, 27}, \\\n                  {25, 26, 28, 29}, {26, 27, 29, 30}, {28, 29, 31, 32}, {29, 30, 32, 33}, \\\n                  {31, 32, 34, 35}, {32, 33, 35, 36}]\t\t\t\t  \n_transversale_simple = [{1, 2, 3, 4, 5, 6}, {4, 5, 6, 7, 8, 9}, {7, 8, 9, 10, 11, 12}, \\\n                  {10, 11, 12, 13, 14, 15}, {13, 14, 15, 16, 17, 18}, {16, 17, 18, 19, 20, 21}, \\\n                  {19, 20, 21, 22, 23, 24}, {22, 23, 24, 25, 26, 27}, {25, 26, 27, 28, 29, 30}, \\\n                  {28, 29, 30, 31, 32, 33}, {31, 32, 33, 34, 35, 36}]\t\t\t\t  \n\t\t\n\t\n", "meta": {"hexsha": "f344e1cda96fa9a3929a1b64d05a5eaed2c2607c", "size": 28515, "ext": "py", "lang": "Python", "max_stars_repo_path": "zufall/lib/objekte/roulette.py", "max_stars_repo_name": "HBOMAT/AglaUndZufall", "max_stars_repo_head_hexsha": "3976fecf024a5e4e771d37a6b8056ca4f7eb0da1", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "zufall/lib/objekte/roulette.py", "max_issues_repo_name": "HBOMAT/AglaUndZufall", "max_issues_repo_head_hexsha": "3976fecf024a5e4e771d37a6b8056ca4f7eb0da1", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "zufall/lib/objekte/roulette.py", "max_forks_repo_name": "HBOMAT/AglaUndZufall", "max_forks_repo_head_hexsha": "3976fecf024a5e4e771d37a6b8056ca4f7eb0da1", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.139183056, "max_line_length": 164, "alphanum_fraction": 0.4418376293, "include": true, "reason": "from sympy", "num_tokens": 8876, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.15203224354320868, "lm_q1q2_score": 0.07601612177160434}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# In[5]:\n\n\nimport os\nfrom sympy import *\nimport pandas as pd\nimport numpy as np\nimport scipy.fftpack\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nplt.style.use(\"seaborn-paper\")\n\ndef find_nearest(array, value):\n    array = np.asarray(array)\n    idx = (np.abs(array - value)).argmin()\n    return idx\n\n\n# ## Canvas palette\n\n# In[6]:\n\n\n#Canvas for single plot\nx = np.linspace(0,10,100)\ny = np.sin(x)\nplt.figure(figsize=[14,6])\nplt.grid(True)\nplt.title(\"Change-me!\",fontsize=20)\nplt.plot(x,y,label=\"testvalue\")\nplt.legend(fontsize=16)\nplt.xlabel(\"XLABEL (unit)\",fontsize=18)\nplt.ylabel(\"YLABEL (unit)\",fontsize=18)\nplt.show()\n\n\n# In[7]:\n\n\n#Canvas for side by side\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(14,6))\nfig.suptitle(\"test\",y=1.05,fontsize=20)\n\naxes[0].grid(True)\naxes[0].plot(x,y,label=\"testvalue\")\naxes[0].legend(fontsize=16)\naxes[0].set_title(\"TESTTITLE\",fontsize=18)\naxes[0].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[0].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[0].legend(fontsize=16)\naxes[0].tick_params(axis='both', which='major', labelsize=15)\n\n\naxes[1].grid(True)\naxes[1].plot(x,y,label=\"testvalue\")\naxes[1].legend(fontsize=16)\naxes[1].set_title(\"TESTTITLE\",fontsize=18)\naxes[1].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[1].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[1].legend(fontsize=16)\naxes[1].tick_params(axis='both', which='major', labelsize=15)\n\nfig.tight_layout()\nplt.show()\n\n\n# In[8]:\n\n\n#Canvas for side by side\nfig, axes = plt.subplots(nrows=2, ncols=4, figsize=(14,6))\nfig.suptitle(\"test\",y=1.05,fontsize=20)\n\naxes[0,0].grid(True)\naxes[0,0].plot(x,y,label=\"testvalue\")\naxes[0,0].legend(fontsize=16)\naxes[0,0].set_title(\"TESTTITLE\",fontsize=18)\naxes[0,0].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[0,0].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[0,0].legend(fontsize=16)\naxes[0,0].tick_params(axis='both', which='major', labelsize=15)\n\n\naxes[0,1].grid(True)\naxes[0,1].plot(x,y,label=\"testvalue\")\naxes[0,1].legend(fontsize=16)\naxes[0,1].set_title(\"TESTTITLE\",fontsize=18)\naxes[0,1].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[0,1].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[0,1].legend(fontsize=16)\naxes[0,1].tick_params(axis='both', which='major', labelsize=15)\n\nfig.tight_layout()\nplt.show()\n\n\n# ## Read data\n\n# In[11]:\n\n\n#Folder and paths definitions\nmain_path  = os.getcwd()\ndatafolder_path = main_path+\"/results\"\nresults_dir = \"/output_py\" \noutput_dir = main_path+results_dir\ntry:\n    os.mkdir(output_dir)\nexcept OSError:\n    print (\"Creation of the directory %s failed\" % results_dir)\nelse:\n    print (\"Successfully created the directory %s \" % results_dir)\n\n\n# In[ ]:\n\n\n\n\n\n# In[81]:\n\n\n#Simulation parameters\nN = 1000\nT = 10000\nn_runs = 10\ndt = .01\nfreq = \"ufreq\"\nfixed_plot = False #--> fixed phase and variable freqs, False viceversa\ngamma = .5\nMF = \"MF\"\n\nif(freq ==\"gfreq\"):\n    freq_plot=\"$\\\\vec{\\\\omega_{0}} = \\\\mathcal{N}(0,1)$\"\nelse:\n    freq_plot=\"$\\\\vec{\\\\omega_{0}} = U(-%.1f,%.1f)$\"%(gamma,gamma)\nif(MF ==\"MF\"):\n    MF_plot=\"MeanField\"\nelse:\n    MF_plot=\"non-meanField\"\n\nif(fixed_plot==True):\n    fixed_plot = \"FixedPhase\"\nelse:\n    fixed_plot = \"FixedFreq\"\n\n\n# In[82]:\n\n\n#OutputFileNames\n#S/N --> |r(t)|/sigma(r(t))\nsn_name = \"S_N\"\n#(Mod&Phase)(t)\nmodphase_name = \"ModPhase_t\"\n#(Mod)(t)\nmod_name = \"Mod_t\"\n#Spectrum\nspectrum_name = \"Spectrum\"\n#r_inf\nrinf_name = \"r_inf\"\n#Configuration-specific name\nif(freq!=\"gfreq\"):\n    config_name= \"/N%d_nruns%d_freq=%s_gamma=%.2f\"%(N,n_runs,freq,gamma)\nelse:\n    config_name= \"/N%d_nruns%d_freq=%s_\"%(N,n_runs,freq)\n\n\n# In[ ]:\n\n\n\n\n\n# In[ ]:\n\n\n\n\n\n# In[84]:\n\n\n#Create dataframe dictionary. For each entry, first value is the K of the dataframe (second value)\ndata = []\nfor i in range(0,n_runs):\n    filename = datafolder_path + \"/PART2_ufreq_uphase_N1000_NOMF_T10000_dt0.0100_nruns10_K1.000_NO_Fphase_Ffreq_RUN%d.tsv\"%(i)\n    #cols refers to timestep, mod, phase, (of order parameter)\n    df = pd.read_csv(filename,sep=\"\\t\",header=None)\n    data.append([\"n_run=%d\"%(i),df])\n    \n\n\n# In[ ]:\n\n\n\n\n\n# ## Plots\n\n# In[ ]:\n\n\n\n\n\n# In[85]:\n\n\n#Plot settings\nalph = 1\ntmax = 100\n\n\nfig, axes = plt.subplots(nrows=1, ncols=1, figsize=(14,6))\n\nfig.suptitle(\"N = %d, dt = %.3f, %s, K=1\"%(N,dt,freq_plot),y=.95,fontsize=20)\n\nplt.grid(True)\n\n#for i in range(0,2):\nfor i in range(0,n_runs):\n    plt.plot(data[i][1][0],data[i][1][1],ls='--',linewidth=.8,markersize=.05,label=\"n_run=%d\"%(i+1),alpha=alph)\n\nplt.title(\"Re[r(t)], fixed $\\\\vec{\\\\omega}(0)$\",fontsize=18)\nplt.xlabel(\"t\",fontsize=18)\nplt.ylabel(\"\",fontsize=18)\nplt.legend(fontsize=16,ncol=2)\nplt.xlim(0,tmax)\nplt.tick_params(axis='both', which='major', labelsize=15)\n\nfig.tight_layout()\nplt.xlim(0,20)\nplt.subplots_adjust(top=.825)\nplt.savefig(output_dir+config_name+mod_name+fixed_plot+\"real.png\")\nplt.show()\n\n\n# In[86]:\n\n\n#Plot settings\nalph = 1\ntmax = 100\n\n\nfig, axes = plt.subplots(nrows=1, ncols=1, figsize=(14,6))\n\nfig.suptitle(\"N = %d, dt = %.3f, %s, K=1\"%(N,dt,freq_plot),y=.95,fontsize=20)\n\nplt.grid(True)\n\n#for i in range(0,2):\nfor i in range(0,n_runs):\n    plt.plot(data[i][1][0],data[i][1][2],ls='--',linewidth=.8,markersize=.05,label=\"n_run=%d\"%(i+1),alpha=alph)\n\nplt.title(\"Im[r(t)], fixed $\\\\vec{\\\\omega}(0)$\",fontsize=18)\nplt.xlabel(\"t\",fontsize=18)\nplt.ylabel(\"\",fontsize=18)\nplt.legend(fontsize=16,ncol=2)\nplt.xlim(0,tmax)\nplt.tick_params(axis='both', which='major', labelsize=15)\n\nfig.tight_layout()\nplt.xlim(0,20)\nplt.subplots_adjust(top=.825)\nplt.savefig(output_dir+config_name+mod_name+fixed_plot+\"imag.png\")\nplt.show()\n\n\n# In[70]:\n\n\n\nfig, axes = plt.subplots(nrows=2, ncols=5, figsize=(14,6))\nfig.suptitle(\"$\\\\mathcal{F} (r(t))$\\nN = %d, dt = %.3f, %s, n_runs = %d\"%(N,dt,freq_plot, n_runs),y=1,fontsize=20)\ncounter1 = 0\ncounter2 = 0\n#for i in range(0,2):\nfor i in range(0,n_runs):\n    if(counter1<n_runs/2):\n        axes[0,counter1].grid(True)\n        im = axes[0,counter1].specgram(data[i][1][1],Fs=1/dt)\n        axes[0,counter1].set_title(\"K = %s\"%(data[i][0]),fontsize=18)\n        axes[0,counter1].set_xlabel(\"t\",fontsize=18)\n        axes[0,counter1].set_ylabel(\"Freq.\",fontsize=18)\n        axes[0,counter1].tick_params(axis='both', which='major', labelsize=15)\n        counter1 = counter1+1\n    else:  \n        axes[1,counter2].grid(True)\n        im = axes[1,counter2].specgram(data[i][1][1],Fs=1/dt)\n        axes[1,counter2].set_title(\"K = %s\"%(data[i][0]),fontsize=18)\n        axes[1,counter2].set_xlabel(\"t\",fontsize=18)\n        axes[1,counter2].set_ylabel(\"Freq.\",fontsize=18)\n        axes[1,counter2].tick_params(axis='both', which='major', labelsize=15)\n        counter2 = counter2+1\n\nfig.tight_layout()\nplt.subplots_adjust(top=.825)\n\nplt.savefig(output_dir+config_name+spectrum_name+\".png\")\n\nplt.show()\n\n\n# In[58]:\n\n\n#for r_inf evaluation\nKval_list = []\nr_inf = []\nr_inf_err = []\nlast_percent = .9\nfor i in range(0,len(Kvalues)):\n    r_inf.append([np.mean(data[i][1][1][int(len(data[i][1][1])*last_percent):])])\n    r_inf_err.append([np.std(data[i][1][1][int(len(data[i][1][1])*last_percent):])])\n    Kval_list.append([Kvalues[i]])\n\n\n# # ADD ERRORBARS\n\n# In[59]:\n\n\n\nfig = plt.figure(figsize=[14,6])\nplt.grid(True)\nplt.title(\"N = %d, dt = %.3f, %s, n_runs = %d\"%(N,dt,freq_plot, n_runs),y=1,fontsize=20)\n#plt.errorbar(Kval_list,r_inf,y_err=r_inf_err,label=\"testvalue\")\nplt.errorbar(Kval_list,r_inf,ls='--',linewidth=.5,fmt='.',markersize=5, elinewidth=.5, capthick=.5,label=\"Average on last %d steps\"%((1-last_percent)*T+1))\nplt.legend(fontsize=16)\nplt.xlabel(\"K\",fontsize=18)\nplt.ylabel(\"$r_{\\\\infty}$\",fontsize=18,rotation=0)\nfig.tight_layout()\nplt.savefig(output_dir+config_name+rinf_name+\".png\")\nplt.show()\n\n\n# In[ ]:\n\n\n\n\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "94d7d8c0d17c1da48d89e539c2785c2816dc57c1", "size": 7669, "ext": "py", "lang": "Python", "max_stars_repo_path": "Code/Python/Part2_analysis.py", "max_stars_repo_name": "spicella/Intro_to_ComplexSystems-Kuramoto", "max_stars_repo_head_hexsha": "64c027f1f0d16b2358d6889de453c1474d3dea6b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-01-04T22:36:10.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-04T22:36:10.000Z", "max_issues_repo_path": "Code/Python/Part2_analysis.py", "max_issues_repo_name": "spicella/Intro_to_ComplexSystems-Kuramoto", "max_issues_repo_head_hexsha": "64c027f1f0d16b2358d6889de453c1474d3dea6b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-01-01T16:13:24.000Z", "max_issues_repo_issues_event_max_datetime": "2020-01-01T16:13:24.000Z", "max_forks_repo_path": "Code/Python/Part2_analysis.py", "max_forks_repo_name": "spicella/IntroCS-Kuramoto", "max_forks_repo_head_hexsha": "64c027f1f0d16b2358d6889de453c1474d3dea6b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.6028169014, "max_line_length": 155, "alphanum_fraction": 0.6667101317, "include": true, "reason": "import numpy,import scipy,from sympy", "num_tokens": 2553, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48047867804790706, "lm_q2_score": 0.1581743527484317, "lm_q1q2_score": 0.0759994039096498}}
{"text": "\n# coding: utf-8\n\n# *Python Machine Learning 2nd Edition* by [Sebastian Raschka](https://sebastianraschka.com) and Vahid Mirjalili, Packt Publishing Ltd. 2017\n# \n# Code Repository: https://github.com/rasbt/python-machine-learning-book-2nd-edition\n# \n# Code License: [MIT License](https://github.com/rasbt/python-machine-learning-book-2nd-edition/blob/master/LICENSE.txt)\n\n# # Python Machine Learning - Code Examples\n\n# # Chapter 16 - Modeling Sequential Data Using Recurrent Neural Networks\n# \n# \n\n# Note that the optional watermark extension is a small IPython notebook plugin that is being used to make the code reproducible. You can just skip the following line(s).\n\n# In[1]:\n\n\n\n\n# *The use of `watermark` is optional. You can install this IPython extension via \"`pip install watermark`\". For more information, please see: https://github.com/rasbt/watermark.*\n\n# - [Introducing sequential data](#Introducing-sequential-data)\n#   - [Modeling sequential data: Order matters](#Modeling-sequential-data:-Order-matters)\n#   - [Understanding the different categories of sequence modeling](#Understanding-the-different-categories-of-sequence-modeling)\n# - [Recurrent neural networks for modeling sequences](#Recurrent-neural-networks-for-modeling-sequences)\n#   - [Understanding the structure and flow of a recurrent neural network \n# ](#Understanding-the-structure-and-flow-of-a-recurrent-neural-network)\n#   - [Computing activations in an RNN](#Computing-activations-in-an-RNN)\n#   - [The challenges of learning long-range interactions](#The-challenges-of-learning-long-range-interactions)\n#   - [Long short-term memory units](#Long-short-term-memory-units)\n# - [Implementing a multilayer RNN for sequence modeling in TensorFlow](#Implementing-a-multilayer-RNN-for-sequence-modeling-in-TensorFlow)\n#   - [Performing sentiment analysis of IMDb movie reviews using multilayer RNNs](#Performing-sentiment-analysis-of-IMDb-movie-reviews-using-multilayer-RNNs)\n#     - [Preparing the data](#Preparing-the-data)\n#     - [Embedding](#Embedding)\n#     - [Building the RNN model](#Building-the-RNN-model)\n#       - [Step 1: Defining multilayer RNN cells](#Step-1:-Defining-multilayer-RNN-cells)\n#       - [Step 2: Defining the initial states for the RNN cells](#Step-2:-Defining-the-initial-states-for-the-RNN-cells)\n#       - [Step 3: Creating the recurrent neural network using the RNN cells and their states](#Step-3:-Creating-the-recurrent-neural-network-using-the-RNN-cells-and-their-states)\n#   - [Example application: character-level language modeling](#Example-application:-character-level-language-modeling)\n#     - [Preparing the data](#Preparing-the-data)\n#     - [Building the character-level RNN model](#Building-the-character-level-RNN-model)\n# - [Summary](#Summary)\n\n# In[2]:\n\n\nfrom IPython.display import Image\n\n\n# In[ ]:\n\n\nimport gzip\n\n\nwith gzip.open('movie_data.csv.gz') as f_in, open('movie_data.csv', 'wb') as f_out:\n    f_out.writelines(f_in)\n\n\n# # Introducing sequential data \n\n# ## Modeling sequential data: Order matters\n\n# ## Representing sequences\n\n# In[3]:\n\n\n\n\n# ## Understanding the different categories of sequence modeling\n\n# In[4]:\n\n\n\n\n# # Recurrent neural networks for modeling sequences\n\n# ## Understanding the structure and flow of a recurrent neural network \n\n# In[5]:\n\n\n\n\n# In[6]:\n\n\n\n\n# ## Computing activations in an RNN\n\n# In[7]:\n\n\n\n\n# In[8]:\n\n\n\n\n# ## The challenges of learning long-range interactions\n\n# In[9]:\n\n\n\n\n# ## Long short-term memory units\n\n# In[10]:\n\n\n\n\n# # Implementing a multilayer RNN for sequence modeling in TensorFlow\n\n# ## Performing sentiment analysis of IMDb movie reviews using multilayer RNNs\n\n# ### Preparing the data\n\n# In[11]:\n\n\n\n\n# In[1]:\n\n\nimport pyprind\nimport pandas as pd\nfrom string import punctuation\nimport re\nimport numpy as np\n\n\ndf = pd.read_csv('movie_data.csv', encoding='utf-8')\nprint(df.head(3))\n\n\n# In[ ]:\n\n\n## @Readers: PLEASE IGNORE THIS CELL\n##\n## This cell is meant to shrink the\n## dataset when this notebook is run \n## on the Travis Continuous Integration\n## platform to test the code as well as\n## speeding up the run using a smaller\n## dataset for debugging\n\nimport os\n\n\nif 'TRAVIS' in os.environ:\n    df = pd.read_csv('movie_data.csv', encoding='utf-8', nrows=500)\n\n\n# In[2]:\n\n\n## Preprocessing the data:\n## Separate words and \n## count each word's occurrence\n\n\nfrom collections import Counter\n\n\ncounts = Counter()\npbar = pyprind.ProgBar(len(df['review']),\n                       title='Counting words occurences')\nfor i,review in enumerate(df['review']):\n    text = ''.join([c if c not in punctuation else ' '+c+' '                     for c in review]).lower()\n    df.loc[i,'review'] = text\n    pbar.update()\n    counts.update(text.split())\n\n\n# In[3]:\n\n\n## Create a mapping:\n## Map each unique word to an integer\n\nword_counts = sorted(counts, key=counts.get, reverse=True)\nprint(word_counts[:5])\nword_to_int = {word: ii for ii, word in enumerate(word_counts, 1)}\n\n\nmapped_reviews = []\npbar = pyprind.ProgBar(len(df['review']),\n                       title='Map reviews to ints')\nfor review in df['review']:\n    mapped_reviews.append([word_to_int[word] for word in review.split()])\n    pbar.update()\n\n\n# In[4]:\n\n\n## Define fixed-length sequences:\n## Use the last 200 elements of each sequence\n## if sequence length < 200: left-pad with zeros\n\nsequence_length = 200  ## sequence length (or T in our formulas)\nsequences = np.zeros((len(mapped_reviews), sequence_length), dtype=int)\nfor i, row in enumerate(mapped_reviews):\n    review_arr = np.array(row)\n    sequences[i, -len(row):] = review_arr[-sequence_length:]\n\nX_train = sequences[:25000, :]\ny_train = df.loc[:25000, 'sentiment'].values\nX_test = sequences[25000:, :]\ny_test = df.loc[25000:, 'sentiment'].values\n\n\nnp.random.seed(123) # for reproducibility\n\n## Function to generate minibatches:\ndef create_batch_generator(x, y=None, batch_size=64):\n    n_batches = len(x)//batch_size\n    x= x[:n_batches*batch_size]\n    if y is not None:\n        y = y[:n_batches*batch_size]\n    for ii in range(0, len(x), batch_size):\n        if y is not None:\n            yield x[ii:ii+batch_size], y[ii:ii+batch_size]\n        else:\n            yield x[ii:ii+batch_size]\n\n\n# In[ ]:\n\n\n## @Readers: PLEASE IGNORE THIS CELL\n##\n## This cell is meant to shrink the\n## dataset when this notebook is run \n## on the Travis Continuous Integration\n## platform to test the code as well as\n## speeding up the run using a smaller\n## dataset for debugging\n\nif 'TRAVIS' in os.environ:\n    X_train = sequences[:250, :]\n    y_train = df.loc[:250, 'sentiment'].values\n    X_test = sequences[250:500, :]\n    y_test = df.loc[250:500, 'sentiment'].values\n\n\n# ### Embedding\n\n# In[12]:\n\n\n\n\n# ### Building the RNN model\n\n# In[5]:\n\n\nimport tensorflow as tf\n\n\nclass SentimentRNN(object):\n    def __init__(self, n_words, seq_len=200,\n                 lstm_size=256, num_layers=1, batch_size=64,\n                 learning_rate=0.0001, embed_size=200):\n        self.n_words = n_words\n        self.seq_len = seq_len\n        self.lstm_size = lstm_size   ## number of hidden units\n        self.num_layers = num_layers\n        self.batch_size = batch_size\n        self.learning_rate = learning_rate\n        self.embed_size = embed_size\n\n        self.g = tf.Graph()\n        with self.g.as_default():\n            tf.set_random_seed(123)\n            self.build()\n            self.saver = tf.train.Saver()\n            self.init_op = tf.global_variables_initializer()\n\n    def build(self):\n        ## Define the placeholders\n        tf_x = tf.placeholder(tf.int32,\n                    shape=(self.batch_size, self.seq_len),\n                    name='tf_x')\n        tf_y = tf.placeholder(tf.float32,\n                    shape=(self.batch_size),\n                    name='tf_y')\n        tf_keepprob = tf.placeholder(tf.float32,\n                    name='tf_keepprob')\n        ## Create the embedding layer\n        embedding = tf.Variable(\n                    tf.random_uniform(\n                        (self.n_words, self.embed_size),\n                        minval=-1, maxval=1),\n                    name='embedding')\n        embed_x = tf.nn.embedding_lookup(\n                    embedding, tf_x, \n                    name='embeded_x')\n\n        ## Define LSTM cell and stack them together\n        cells = tf.contrib.rnn.MultiRNNCell(\n                [tf.contrib.rnn.DropoutWrapper(\n                   tf.contrib.rnn.BasicLSTMCell(self.lstm_size),\n                   output_keep_prob=tf_keepprob)\n                 for i in range(self.num_layers)])\n\n        ## Define the initial state:\n        self.initial_state = cells.zero_state(\n                 self.batch_size, tf.float32)\n        print('  << initial state >> ', self.initial_state)\n\n        lstm_outputs, self.final_state = tf.nn.dynamic_rnn(\n                 cells, embed_x,\n                 initial_state=self.initial_state)\n        ## Note: lstm_outputs shape: \n        ##  [batch_size, max_time, cells.output_size]\n        print('\\n  << lstm_output   >> ', lstm_outputs)\n        print('\\n  << final state   >> ', self.final_state)\n\n        ## Apply a FC layer after on top of RNN output:\n        logits = tf.layers.dense(\n                 inputs=lstm_outputs[:, -1],\n                 units=1, activation=None,\n                 name='logits')\n        \n        logits = tf.squeeze(logits, name='logits_squeezed')\n        print ('\\n  << logits        >> ', logits)\n        \n        y_proba = tf.nn.sigmoid(logits, name='probabilities')\n        predictions = {\n            'probabilities': y_proba,\n            'labels' : tf.cast(tf.round(y_proba), tf.int32,\n                 name='labels')\n        }\n        print('\\n  << predictions   >> ', predictions)\n\n        ## Define the cost function\n        cost = tf.reduce_mean(\n                 tf.nn.sigmoid_cross_entropy_with_logits(\n                 labels=tf_y, logits=logits),\n                 name='cost')\n        \n        ## Define the optimizer\n        optimizer = tf.train.AdamOptimizer(self.learning_rate)\n        train_op = optimizer.minimize(cost, name='train_op')\n\n    def train(self, X_train, y_train, num_epochs):\n        with tf.Session(graph=self.g) as sess:\n            sess.run(self.init_op)\n            iteration = 1\n            for epoch in range(num_epochs):\n                state = sess.run(self.initial_state)\n                \n                for batch_x, batch_y in create_batch_generator(\n                            X_train, y_train, self.batch_size):\n                    feed = {'tf_x:0': batch_x,\n                            'tf_y:0': batch_y,\n                            'tf_keepprob:0': 0.5,\n                            self.initial_state : state}\n                    loss, _, state = sess.run(\n                            ['cost:0', 'train_op', \n                             self.final_state],\n                            feed_dict=feed)\n\n                    if iteration % 20 == 0:\n                        print(\"Epoch: %d/%d Iteration: %d \"\n                              \"| Train loss: %.5f\" % (\n                               epoch + 1, num_epochs,\n                               iteration, loss))\n\n                    iteration +=1\n                if (epoch+1)%10 == 0:\n                    self.saver.save(sess,\n                        \"model/sentiment-%d.ckpt\" % epoch)\n\n    def predict(self, X_data, return_proba=False):\n        preds = []\n        with tf.Session(graph = self.g) as sess:\n            self.saver.restore(\n                sess, tf.train.latest_checkpoint('model/'))\n            test_state = sess.run(self.initial_state)\n            for ii, batch_x in enumerate(\n                create_batch_generator(\n                    X_data, None, batch_size=self.batch_size), 1):\n                feed = {'tf_x:0' : batch_x,\n                        'tf_keepprob:0': 1.0,\n                        self.initial_state : test_state}\n                if return_proba:\n                    pred, test_state = sess.run(\n                        ['probabilities:0', self.final_state],\n                        feed_dict=feed)\n                else:\n                    pred, test_state = sess.run(\n                        ['labels:0', self.final_state],\n                        feed_dict=feed)\n                    \n                preds.append(pred)\n                \n        return np.concatenate(preds)\n\n\n# #### Step 1: Defining multilayer RNN cells\n\n# #### Step 2: Defining the initial states for the RNN cells\n# \n\n# #### Step 3: Creating the recurrent neural network using the RNN cells and their states\n# \n# \n\n# In[6]:\n\n\n## Train:\n\nn_words = max(list(word_to_int.values())) + 1\n\nrnn = SentimentRNN(n_words=n_words, \n                   seq_len=sequence_length,\n                   embed_size=256, \n                   lstm_size=128, \n                   num_layers=1, \n                   batch_size=100, \n                   learning_rate=0.001)\n\n\n# In[7]:\n\n\nrnn.train(X_train, y_train, num_epochs=40)\n\n\n# In[ ]:\n\n\n## Test: \npreds = rnn.predict(X_test)\ny_true = y_test[:len(preds)]\nprint('Test Acc.: %.3f' % (\n      np.sum(preds == y_true) / len(y_true)))\n\n\n# In[ ]:\n\n\n## Get probabilities:\nproba = rnn.predict(X_test, return_proba=True)\n\n\n# ## Example application: character-level language modeling\n\n# In[13]:\n\n\n\n\n# ### Preparing the data\n# \n\n# In[14]:\n\n\n\n\n# In[15]:\n\n\n\n\n# In[16]:\n\n\n\n\n# In[1]:\n\n\nimport numpy as np\n\n\n## Reading and processing text\nwith open('pg2265.txt', 'r', encoding='utf-8') as f: \n    text=f.read()\n\ntext = text[15858:]\nchars = set(text)\nchar2int = {ch:i for i,ch in enumerate(chars)}\nint2char = dict(enumerate(chars))\ntext_ints = np.array([char2int[ch] for ch in text], \n                     dtype=np.int32)\n\n\n# In[ ]:\n\n\n## @Readers: PLEASE IGNORE THIS CELL\n##\n## This cell is meant to shrink the\n## dataset when this notebook is run \n## on the Travis Continuous Integration\n## platform to test the code as well as\n## speeding up the run using a smaller\n## dataset for debugging\n\nif 'TRAVIS' in os.environ:\n    text = text[:1000]\n    chars = set(text)\n    char2int = {ch:i for i,ch in enumerate(chars)}\n    int2char = dict(enumerate(chars))\n    text_ints = np.array([char2int[ch] for ch in text], \n                         dtype=np.int32)\n\n\n# In[2]:\n\n\ndef reshape_data(sequence, batch_size, num_steps):\n    tot_batch_length = batch_size * num_steps\n    num_batches = int(len(sequence) / tot_batch_length)\n    if num_batches*tot_batch_length + 1 > len(sequence):\n        num_batches = num_batches - 1\n    ## Truncate the sequence at the end to get rid of \n    ## remaining charcaters that do not make a full batch\n    x = sequence[0 : num_batches*tot_batch_length]\n    y = sequence[1 : num_batches*tot_batch_length + 1]\n    ## Split x & y into a list batches of sequences: \n    x_batch_splits = np.split(x, batch_size)\n    y_batch_splits = np.split(y, batch_size)\n    ## Stack the batches together\n    ## batch_size x tot_batch_length\n    x = np.stack(x_batch_splits)\n    y = np.stack(y_batch_splits)\n    \n    return x, y\n\n## Testing:\ntrain_x, train_y = reshape_data(text_ints, 64, 10)\nprint(train_x.shape)\nprint(train_x[0, :10])\nprint(train_y[0, :10])\nprint(''.join(int2char[i] for i in train_x[0, :50]))\n\n\n# In[3]:\n\n\nnp.random.seed(123)\n\ndef create_batch_generator(data_x, data_y, num_steps):\n    batch_size, tot_batch_length = data_x.shape    \n    num_batches = int(tot_batch_length/num_steps)\n    for b in range(num_batches):\n        yield (data_x[:, b*num_steps: (b+1)*num_steps], \n               data_y[:, b*num_steps: (b+1)*num_steps])\n        \nbgen = create_batch_generator(train_x[:,:100], train_y[:,:100], 15)\nfor b in bgen:\n    print(b[0].shape, b[1].shape, end='  ')\n    print(''.join(int2char[i] for i in b[0][0,:]).replace('\\n', '*'), '    ',\n          ''.join(int2char[i] for i in b[1][0,:]).replace('\\n', '*'))\n\n\n# ### Building the character-level RNN model\n\n# In[4]:\n\n\nimport tensorflow as tf\nimport os\n\nclass CharRNN(object):\n    def __init__(self, num_classes, batch_size=64, \n                 num_steps=100, lstm_size=128, \n                 num_layers=1, learning_rate=0.001, \n                 keep_prob=0.5, grad_clip=5, \n                 sampling=False):\n        self.num_classes = num_classes\n        self.batch_size = batch_size\n        self.num_steps = num_steps\n        self.lstm_size = lstm_size\n        self.num_layers = num_layers\n        self.learning_rate = learning_rate\n        self.keep_prob = keep_prob\n        self.grad_clip = grad_clip\n        \n        self.g = tf.Graph()\n        with self.g.as_default():\n            tf.set_random_seed(123)\n\n            self.build(sampling=sampling)\n            self.saver = tf.train.Saver()\n            self.init_op = tf.global_variables_initializer()\n            \n    def build(self, sampling):\n        if sampling == True:\n            batch_size, num_steps = 1, 1\n        else:\n            batch_size = self.batch_size\n            num_steps = self.num_steps\n\n        tf_x = tf.placeholder(tf.int32, \n                              shape=[batch_size, num_steps], \n                              name='tf_x')\n        tf_y = tf.placeholder(tf.int32, \n                              shape=[batch_size, num_steps], \n                              name='tf_y')\n        tf_keepprob = tf.placeholder(tf.float32, \n                              name='tf_keepprob')\n\n        # One-hot encoding:\n        x_onehot = tf.one_hot(tf_x, depth=self.num_classes)\n        y_onehot = tf.one_hot(tf_y, depth=self.num_classes)\n\n        ### Build the multi-layer RNN cells\n        cells = tf.contrib.rnn.MultiRNNCell(\n            [tf.contrib.rnn.DropoutWrapper(\n                tf.contrib.rnn.BasicLSTMCell(self.lstm_size), \n                output_keep_prob=tf_keepprob) \n            for _ in range(self.num_layers)])\n        \n        ## Define the initial state\n        self.initial_state = cells.zero_state(\n                    batch_size, tf.float32)\n\n        ## Run each sequence step through the RNN \n        lstm_outputs, self.final_state = tf.nn.dynamic_rnn(\n                    cells, x_onehot, \n                    initial_state=self.initial_state)\n        \n        print('  << lstm_outputs  >>', lstm_outputs)\n\n        seq_output_reshaped = tf.reshape(\n                    lstm_outputs, \n                    shape=[-1, self.lstm_size],\n                    name='seq_output_reshaped')\n\n        logits = tf.layers.dense(\n                    inputs=seq_output_reshaped, \n                    units=self.num_classes,\n                    activation=None,\n                    name='logits')\n\n        proba = tf.nn.softmax(\n                    logits, \n                    name='probabilities')\n        print(proba)\n\n        y_reshaped = tf.reshape(\n                    y_onehot, \n                    shape=[-1, self.num_classes],\n                    name='y_reshaped')\n        cost = tf.reduce_mean(\n                    tf.nn.softmax_cross_entropy_with_logits(\n                        logits=logits, \n                        labels=y_reshaped),\n                    name='cost')\n\n        # Gradient clipping to avoid \"exploding gradients\"\n        tvars = tf.trainable_variables()\n        grads, _ = tf.clip_by_global_norm(\n                    tf.gradients(cost, tvars), \n                    self.grad_clip)\n        optimizer = tf.train.AdamOptimizer(self.learning_rate)\n        train_op = optimizer.apply_gradients(\n                    zip(grads, tvars),\n                    name='train_op')\n        \n    def train(self, train_x, train_y, \n              num_epochs, ckpt_dir='./model/'):\n        ## Create the checkpoint directory\n        ## if does not exists\n        if not os.path.exists(ckpt_dir):\n            os.mkdir(ckpt_dir)\n            \n        with tf.Session(graph=self.g) as sess:\n            sess.run(self.init_op)\n\n            n_batches = int(train_x.shape[1]/self.num_steps)\n            iterations = n_batches * num_epochs\n            for epoch in range(num_epochs):\n\n                # Train network\n                new_state = sess.run(self.initial_state)\n                loss = 0\n                ## Minibatch generator:\n                bgen = create_batch_generator(\n                        train_x, train_y, self.num_steps)\n                for b, (batch_x, batch_y) in enumerate(bgen, 1):\n                    iteration = epoch*n_batches + b\n                    \n                    feed = {'tf_x:0': batch_x,\n                            'tf_y:0': batch_y,\n                            'tf_keepprob:0': self.keep_prob,\n                            self.initial_state : new_state}\n                    batch_cost, _, new_state = sess.run(\n                            ['cost:0', 'train_op', \n                                self.final_state],\n                            feed_dict=feed)\n                    if iteration % 10 == 0:\n                        print('Epoch %d/%d Iteration %d'\n                              '| Training loss: %.4f' % (\n                              epoch + 1, num_epochs, \n                              iteration, batch_cost))\n\n                ## Save the trained model    \n                self.saver.save(\n                        sess, os.path.join(\n                            ckpt_dir, 'language_modeling.ckpt'))\n                              \n                              \n                \n    def sample(self, output_length, \n               ckpt_dir, starter_seq=\"The \"):\n        observed_seq = [ch for ch in starter_seq]        \n        with tf.Session(graph=self.g) as sess:\n            self.saver.restore(\n                sess, \n                tf.train.latest_checkpoint(ckpt_dir))\n            ## 1: run the model using the starter sequence\n            new_state = sess.run(self.initial_state)\n            for ch in starter_seq:\n                x = np.zeros((1, 1))\n                x[0,0] = char2int[ch]\n                feed = {'tf_x:0': x,\n                        'tf_keepprob:0': 1.0,\n                        self.initial_state: new_state}\n                proba, new_state = sess.run(\n                        ['probabilities:0', self.final_state], \n                        feed_dict=feed)\n\n            ch_id = get_top_char(proba, len(chars))\n            observed_seq.append(int2char[ch_id])\n            \n            ## 2: run the model using the updated observed_seq\n            for i in range(output_length):\n                x[0,0] = ch_id\n                feed = {'tf_x:0': x,\n                        'tf_keepprob:0': 1.0,\n                        self.initial_state: new_state}\n                proba, new_state = sess.run(\n                        ['probabilities:0', self.final_state], \n                        feed_dict=feed)\n\n                ch_id = get_top_char(proba, len(chars))\n                observed_seq.append(int2char[ch_id])\n\n        return ''.join(observed_seq)\n\n\n# In[5]:\n\n\ndef get_top_char(probas, char_size, top_n=5):\n    p = np.squeeze(probas)\n    p[np.argsort(p)[:-top_n]] = 0.0\n    p = p / np.sum(p)\n    ch_id = np.random.choice(char_size, 1, p=p)[0]\n    return ch_id\n\n\n# In[6]:\n\n\nbatch_size = 64\nnum_steps = 100 \ntrain_x, train_y = reshape_data(text_ints, \n                                batch_size, \n                                num_steps)\n\nrnn = CharRNN(num_classes=len(chars), batch_size=batch_size)\nrnn.train(train_x, train_y, \n          num_epochs=100,\n          ckpt_dir='./model-100/')\n\n\n# In[7]:\n\n\nnp.random.seed(123)\nrnn = CharRNN(len(chars), sampling=True)\n\nprint(rnn.sample(ckpt_dir='./model-100/', \n                 output_length=500))\n\n\n# In[8]:\n\n\n## run for 200 epochs\nbatch_size = 64\nnum_steps = 100 \n\nrnn = CharRNN(num_classes=len(chars), batch_size=batch_size)\nrnn.train(train_x, train_y, \n          num_epochs=200,\n          ckpt_dir='./model-200/')\n\n\n# In[9]:\n\n\ndel rnn\n\nnp.random.seed(123)\nrnn = CharRNN(len(chars), sampling=True)\nprint(rnn.sample(ckpt_dir='./model-200/', \n                 output_length=500))\n\n\n# # Summary\n\n# ...\n\n# ---\n# \n# Readers may ignore the next cell.\n\n# In[ ]:\n\n\n\n", "meta": {"hexsha": "4e0880c2fb609d8ae8a4635a0baa1a2daf3c5035", "size": 23863, "ext": "py", "lang": "Python", "max_stars_repo_path": "MachineLearningBooks/PyML Example Code/Chapter16/ch16.py", "max_stars_repo_name": "alexdarch/PythonProjects", "max_stars_repo_head_hexsha": "0905326865efd20e922eba47aedb983bf0844b64", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-06-13T10:49:48.000Z", "max_stars_repo_stars_event_max_datetime": "2018-06-13T10:49:48.000Z", "max_issues_repo_path": "MachineLearningBooks/PyML Example Code/Chapter16/ch16.py", "max_issues_repo_name": "alexdarch/PythonProjects", "max_issues_repo_head_hexsha": "0905326865efd20e922eba47aedb983bf0844b64", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "MachineLearningBooks/PyML Example Code/Chapter16/ch16.py", "max_forks_repo_name": "alexdarch/PythonProjects", "max_forks_repo_head_hexsha": "0905326865efd20e922eba47aedb983bf0844b64", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.6127098321, "max_line_length": 179, "alphanum_fraction": 0.5718895361, "include": true, "reason": "import numpy", "num_tokens": 5568, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48438008427698437, "lm_q2_score": 0.15405756463346182, "lm_q1q2_score": 0.0746224161406632}}
{"text": "\"\"\"\nIntroduction to Radar Course\n\nAuthors\n=======\n\nZachary Chance, Robert Freking, Victoria Helus\nMIT Lincoln Laboratory\nLexington, MA 02421\n\nDistribution Statement\n======================\n\nDISTRIBUTION STATEMENT A. Approved for public release. Distribution is unlimited.\n\nThis material is based upon work supported by the United States Air Force under Air \nForce Contract No. FA8702-15-D-0001. Any opinions, findings, conclusions or \nrecommendations expressed in this material are those of the author(s) and do not \nnecessarily reflect the views of the United States Air Force.\n\n© 2021 Massachusetts Institute of Technology.\n\nThe software/firmware is provided to you on an As-Is basis\n\nDelivered to the U.S. Government with Unlimited Rights, as defined in DFARS Part \n252.227-7013 or 7014 (Feb 2014). Notwithstanding any copyright notice, U.S. \nGovernment rights in this work are defined by DFARS 252.227-7013 or \nDFARS 252.227-7014 as detailed above. Use of this work other than as specifically \nauthorized by the U.S. Government may violate any copyrights that exist in this work.\n\nRAMS ID: 1016938\n\"\"\"\n\nfrom IPython.display import display\nimport ipywidgets as wdg\nimport math\nimport numpy as np\nfrom rad.const import k, c\nimport rad.radar as rd\n\n# jupyter_intro\n\n# Simple quiz with scalar value\ndef new_quiz(prompt, val, abs_tol=None, rel_tol=1E-2):\n    \"\"\"\n    Generate quiz answer box.\n    \n    Inputs:\n    - prompt [str]: Question prompt\n    - val [float]: True answer\n    - abs_tol [float]: Absolute tolerance; if None, uses rel_tol\n    - rel_tol [float]: Relative tolerance\n    \n    Outputs:\n    (none)\n    \"\"\"\n    title = wdg.HTML(value = f\"<p><font color='black'>{prompt}</p>\")\n    answer = wdg.FloatText()\n    submit = wdg.Button(description=\"Submit\")\n    result = wdg.HTML(value = f\"<b><font color='black'>Ready</b>\")\n    ansbox = wdg.VBox([wdg.HBox([title, answer, result]), submit])\n    display(ansbox)\n\n    def check_ans(b):\n        if abs_tol and (abs(answer.value - val) < abs_tol):\n            result.value = f\"<b><font color='green'>Correct!</b>\"\n        elif rel_tol and ((abs(answer.value - val)/abs(val)) < rel_tol):\n            result.value = f\"<b><font color='green'>Correct!</b>\"\n        else:\n            result.value = f\"<b><font color='red'>Incorrect.</b>\"\n        \n    submit.on_click(check_ans)\n\n#-------Lab 1.1: Introduction to Labs-------\n    \n# Q1.1.1\ndef quiz_1_1_1():\n    prompt = 'Enter answer:'\n    val = 1.0\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n\n# Q1.1.2\ndef quiz_1_1_2():\n    prompt = 'Enter answer:'\n    val = (math.log10(2.72**3) + math.cos(4*math.pi/7))\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.1.3\ndef quiz_1_1_3():\n    prompt = 'Enter answer:'\n    val = 7.76E4/5.1E-3\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.1.4a\ndef quiz_1_1_4a():\n    prompt = 'Enter answer (in dB):'\n    val = rd.to_db(1.5E5)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.1.4b\ndef quiz_1_1_4b():\n    prompt = 'Enter answer (in dB):'\n    val = rd.to_db(7.2E-7)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol) \n\n# Q1.1.5a\ndef quiz_1_1_5a():\n    prompt = 'Enter answer:'\n    val = rd.from_db(51.2)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.1.5b\ndef quiz_1_1_5b():\n    prompt = 'Enter answer:'\n    val = rd.from_db(-20.1)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol) \n    \n# Q1.1.6\ndef quiz_1_1_6():\n    prompt = 'Enter answer (in dB):'\n    val = rd.to_db(3.7**5)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.1.7a\ndef quiz_1_1_7a():\n    prompt = 'Enter answer:'\n    val = 3\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.1.7b\ndef quiz_1_1_7b():\n    prompt = 'Enter answer (in s, within ±0.05 s):'\n    val = 0.5\n    tol = 0.05\n    new_quiz(prompt, val, abs_tol=tol)\n    \n# Q1.1.7c\ndef quiz_1_1_7c():\n    prompt = 'Enter answer (in Hz, within ±0.2 Hz):'\n    val = 2\n    tol = 0.2\n    new_quiz(prompt, val, abs_tol=tol) \n    \n#-------Lab 1.2: Introduction to Radar-------\n    \n# Q1.2.1a\ndef quiz_1_2_1a():\n    prompt = 'Enter wavelength (in m):'\n    val = rd.wavelen(1000, propvel=1000)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.2.1b\ndef quiz_1_2_1b():\n    prompt = 'Enter wavelength (in m):'\n    val = rd.wavelen(1000, propvel=2000)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)    \n\n# Q1.2.1c\ndef quiz_1_2_1c():\n    prompt = 'Enter wavelength (in m):'\n    val = rd.wavelen(500, propvel=1000)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)    \n    \n# Q1.2.2a\ndef quiz_1_2_2a():\n    prompt = 'Enter wavelength (in m):'\n    val = rd.wavelen(500E6, propvel=3E8)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.2.2b\ndef quiz_1_2_2b():\n    prompt = 'Enter frequency (in Hz):'\n    val = 1500/5\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.2.3a\ndef quiz_1_2_3a():\n    prompt = 'Enter time (in ms):'\n    val = math.sqrt(75**2 + 80**2)\n    tol = 3\n    new_quiz(prompt, val, abs_tol=tol)\n    \n# Q1.2.3b\ndef quiz_1_2_3b():\n    prompt = 'Enter time (in ms):'\n    val = 2*math.sqrt(75**2 + 80**2)\n    tol = 3\n    new_quiz(prompt, val, abs_tol=tol)\n    \n# Q1.2.4a\ndef quiz_1_2_4a():\n    prompt = 'Enter time (in s):'\n    val = 2*1000E3/3E8\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n\n# Q1.2.4b\ndef quiz_1_2_4b():\n    prompt = 'Enter range (in m):'\n    val = 3E8*0.0057/2\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.2.5\ndef quiz_1_2_5():\n    prompt = 'Enter range (in m):'\n    val = math.sqrt(75**2 + 100**2)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.2.6a\ndef quiz_1_2_6a():\n    prompt = 'Enter range (in m):'\n    val = math.sqrt(50**2 + 50**2)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.2.6b\ndef quiz_1_2_6b():\n    prompt = 'Enter azimuth (in deg, within +/- 3 deg):'\n    val = 90 - rd.rad2deg(math.atan2(50, 50))\n    tol = 3\n    new_quiz(prompt, val, abs_tol=tol)\n    \n# Q1.2.7a\ndef quiz_1_2_7a():\n    prompt = 'Enter range (in m):'\n    val = math.sqrt(40**2 + 20**2)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.2.7b\ndef quiz_1_2_7b():\n    prompt = 'Enter azimuth (in deg, within +/- 3 deg):'\n    val = 90 - rd.rad2deg(math.atan2(-20, 40))\n    tol = 3\n    new_quiz(prompt, val, abs_tol=tol)\n    \n# Q1.2.8a\ndef quiz_1_2_8a():\n    prompt = 'Enter beamwidth (in deg):'\n    val = 70*0.12/3.8\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.2.8b\ndef quiz_1_2_8b():\n    prompt = 'Enter diameter (in m):'\n    val = 70*rd.wavelen(10E9, propvel=3E8)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.2.9\ndef quiz_1_2_9():\n    prompt = 'Enter transmit gain (in dB):'\n    val = rd.to_db(4*math.pi*2.1*3.3/rd.wavelen(15E3, propvel=2E3)**2)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.2.10a\ndef quiz_1_2_10a():\n    prompt = 'Enter wavelength (in m):'\n    val = rd.wavelen(5E9)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.2.10b\ndef quiz_1_2_10b():\n    prompt = 'Enter beamwidth (in deg):'\n    val = 70*rd.wavelen(5E9)/4.4\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q1.2.10c\ndef quiz_1_2_10c():\n    prompt = 'Enter transmit gain (in dB):'\n    val = rd.to_db(4*math.pi*(math.pi*2.2**2)/rd.wavelen(5E9)**2)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n\n#-------Lab 2.1: Radar Range Equation-------\n    \n# Q2.1.1a\ndef quiz_2_1_1a():\n    prompt = 'Enter SNR (in dB):'\n    val = rd.to_db(100/5.3)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q2.1.1b\ndef quiz_2_1_1b():\n    prompt = 'Enter signal energy (in J):'\n    val = rd.from_db(15)*2.2\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)  \n\n# Q2.1.2a\ndef quiz_2_1_2a():\n    prompt = 'Enter received power (in W):'\n    val = rd.friis(50E3, 10E3, area=10, gain=rd.from_db(35.0))\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol) \n\n# Q2.1.2b\ndef quiz_2_1_2b():\n    prompt = 'Enter dish radius (in m):'\n    val = np.sqrt(rd.gain2area((1/100E3/5)*4*np.pi*(10E3)**2, 3.5E9)/np.pi)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol) \n    \n# Q2.1.3a\ndef quiz_2_1_3a():\n    prompt = 'Enter incident power (in W):'\n    val = rd.friis(50E3, 150E3, area=rd.from_db(5), gain=rd.from_db(30))\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol) \n    \n# Q2.1.3b\ndef quiz_2_1_3b():\n    prompt = 'Enter range (in m):'\n    val = math.sqrt(500E3*1*rd.from_db(25)/4/math.pi/0.1E-3)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol) \n    \n# Q2.1.4a\ndef quiz_2_1_4a():\n    prompt = 'Enter received power (in W):'\n    val = rd.rx_power(100E3, 600E3, 3E9, rcs=rd.from_db(5), gain=rd.from_db(80))\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol) \n    \n# Q2.1.4b\ndef quiz_2_1_4b():\n    prompt = 'Enter effective aperture area (in m^2):'\n    val = rd.gain2area(rd.from_db(24.3), 1.3E9)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol) \n    \n# Q2.1.4c\ndef quiz_2_1_4c():\n    prompt = 'Enter RCS (in dBsm):'\n    wlen = rd.wavelen(1.5E9)\n    val = rd.to_db(10E-12*(10E3**4)*(4*np.pi)**3/30/rd.from_db(80)/wlen**2)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol) \n    \n# Q2.1.5\ndef quiz_2_1_5():\n    prompt = 'Enter noise energy (in J):'\n    val = k*722\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol) \n\n# Q2.1.6\ndef quiz_2_1_6():\n    prompt = 'Enter SNR (in dB):'\n    val = rd.to_db(rd.rx_snr(200E3, 50, 5E9, 750, rcs=rd.from_db(-5), gain=rd.from_db(70)))\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol) \n    \n# Q2.1.7\ndef quiz_2_1_7():\n    prompt = 'Enter SNR (in dB):'\n    val = rd.to_db(rd.snrconv(rd.from_db(17), 75E3, rd.from_db(-10), 50E3, rd.from_db(-15)))\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol) \n\n#-------Lab 2.2: Basic Radar Design-------\n    \n#-------Lab 3.1: Radar Transmissions and Receptions-------\n    \n# Q3.1.1\ndef quiz_3_1_1():\n    prompt = 'Enter pulsewidth (in µs):'\n    val = 7.2\n    tol = 0.1\n    new_quiz(prompt, val, abs_tol=tol)\n    \n# Q3.1.2a\ndef quiz_3_1_2a():\n    prompt = 'Enter PRI (in s):'\n    val = 1/10E3\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q3.1.2b\ndef quiz_3_1_2b():\n    prompt = 'Enter duty cycle:'\n    val = 150E-6*1E3\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q3.1.3a\ndef quiz_3_1_3a():\n    prompt = 'Enter delay (in ns):'\n    val = -2.83\n    tol = 0.01\n    new_quiz(prompt, val, abs_tol=tol)\n    \n# Q3.1.3b\ndef quiz_3_1_3b():\n    prompt = 'Enter delay (in ns):'\n    val = -2.83\n    tol = 0.01\n    new_quiz(prompt, val, abs_tol=tol)\n    \n# Q3.1.4a\ndef quiz_3_1_4a():\n    prompt = 'Enter phase (in deg):'\n    val = 168\n    tol = 1\n    new_quiz(prompt, val, abs_tol=tol)\n    \n# Q3.1.4b\ndef quiz_3_1_4b():\n    prompt = 'Enter phase (in deg):'\n    val = 120\n    tol = 1\n    new_quiz(prompt, val, abs_tol=tol)\n    \n# Q3.1.5\ndef quiz_3_1_5():\n    prompt = 'Enter bandwidth (in Hz):'\n    val = c/2/10\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n#-------Lab 3.2: Detection-------\n    \n# Q3.2.1a\ndef quiz_3_2_1a():\n    prompt = 'Enter prob. of detection:'\n    val = 0.69\n    tol = 0.02\n    new_quiz(prompt, val, abs_tol=tol)\n    \n# Q3.2.1b\ndef quiz_3_2_1b():\n    prompt = 'Enter prob. of false alarm:'\n    val = 0.17\n    tol = 0.02\n    new_quiz(prompt, val, abs_tol=tol)\n    \n#-------Lab 4.1: Target Parameter Estimation-------\n    \n# Q4.1.1a\ndef quiz_4_1_1a():\n    prompt = 'Enter range (in m):'\n    val = c*0.00333/2\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q4.1.1b\ndef quiz_4_1_1b():\n    prompt = 'Enter range resolution (in m):'\n    val = rd.range_res(30E6)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q4.1.1c\ndef quiz_4_1_1c():\n    prompt = 'Enter range accuracy (in m):'\n    val = rd.range_res(30E6)/np.sqrt(rd.from_db(11))\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q4.1.2a\ndef quiz_4_1_2a():\n    prompt = 'Enter angle accuracy (in deg):'\n    val = rd.dish_beamw(2, 3.5E9)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q4.1.2b\ndef quiz_4_1_2b():\n    prompt = 'Enter angle accuracy (in deg):'\n    val = rd.dish_beamw(2, 3.5E9)/np.sqrt(rd.from_db(14))\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q4.1.3\ndef quiz_4_1_3():\n    prompt = 'Enter cross-range resolution (in m):'\n    val = 50E3*rd.wavelen(3.5E9)/2.1\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q4.1.4a\ndef quiz_4_1_4a():\n    prompt = 'Enter Doppler shift (in Hz):'\n    val = rd.dopp_shift(500, 1.5E9)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q4.1.4b\ndef quiz_4_1_4b():\n    prompt = 'Enter range rate (in m/s):'\n    val = -c*10E3/2/3.0E9\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q4.1.5\ndef quiz_4_1_5():\n    prompt = 'Enter range rate (in m/s):'\n    val = 55.0\n    tol = 1.0\n    new_quiz(prompt, val, abs_tol=tol)\n    \n# Q4.1.6a\ndef quiz_4_1_6a():\n    prompt = 'Enter range rate resolution (in m/s):'\n    val = c/2/5E9/50E-3\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q4.1.6b\ndef quiz_4_1_6b():\n    prompt = 'Enter range rate (in m/s):'\n    val = c*500/4/5E9\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q4.1.7a\ndef quiz_4_1_7a():\n    prompt = 'Enter RCS (in dBsm):'\n    val = rd.to_db(rd.from_db(0)*(rd.from_db(13)/rd.from_db(15))*(65E3/50E3)**4)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q4.1.7b\ndef quiz_4_1_7b():\n    prompt = 'Enter RCS (in dBsm):'\n    val = rd.to_db(rd.from_db(5)*(rd.from_db(13)/rd.from_db(7))*(100E3/500E3)**4)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q5.1.1a\ndef quiz_5_1_1a():\n    prompt = 'Enter wavelength (in m):'\n    val = rd.wavelen(10E9)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q5.1.1b\ndef quiz_5_1_1b():\n    prompt = 'Enter beamwidth (in deg):'\n    val = 70*rd.wavelen(10E9)/4\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q5.1.1c\ndef quiz_5_1_1c():\n    prompt = 'Enter transmit gain (in dB):'\n    val = rd.to_db(rd.dish_gain(2, 10E9))\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q5.1.2a\ndef quiz_5_1_2a():\n    prompt = 'Enter received energy (in J):'\n    val = rd.rx_energy(200E3, 10, 2E9, gain=rd.area2gain(10, 2E9)**2, rcs=rd.from_db(-5))\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q5.1.2b\ndef quiz_5_1_2b():\n    prompt = 'Enter SNR (in dB):'\n    val = rd.to_db(rd.rx_energy(200E3, 10, 2E9, gain=rd.area2gain(10, 2E9)**2, rcs=rd.from_db(-5))) - \\\n        rd.to_db(k*500)\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q5.1.3a\ndef quiz_5_1_3a():\n    prompt = 'Enter duty cycle:'\n    val = 100E-6*2E3\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q5.1.3b\ndef quiz_5_1_3b():\n    prompt = 'Enter number of pulses:'\n    val = math.ceil(rd.from_db(12))\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q5.1.4a\ndef quiz_5_1_4a():\n    prompt = 'Enter bandwidth (in Hz):'\n    val = c/2/1.5\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q5.1.4b\ndef quiz_5_1_4b():\n    prompt = 'Enter cross range resolution (in m):'\n    beamw = 57.3*rd.wavelen(5E9)/5.2\n    val = 90E3*beamw/57.3\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q5.1.4c\ndef quiz_5_1_4c():\n    prompt = 'Enter range rate (in m/s):'\n    val = c*700/4/3E9\n    tol = 0.01\n    new_quiz(prompt, val, rel_tol=tol)\n    \n# Q5.1.5\ndef quiz_5_1_5(targets):\n    for ii in range(len(targets)): \n        prompt = f'Enter route number for target with RCS {targets[ii].rcs:.2f} dBsm:'\n        val = targets[ii].route\n        tol = 0.01\n        new_quiz(prompt, val, abs_tol=tol)\n", "meta": {"hexsha": "c1e3786c6c44bd62d03370c38e35e881f6238820", "size": 15550, "ext": "py", "lang": "Python", "max_stars_repo_path": "rad/quiz.py", "max_stars_repo_name": "mit-ll/radar-intro", "max_stars_repo_head_hexsha": "9ff2ac5d263c9ceddafed320a65396fb8258fb32", "max_stars_repo_licenses": ["FSFULLR", "FSFUL"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-17T21:08:58.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-17T21:08:58.000Z", "max_issues_repo_path": "rad/quiz.py", "max_issues_repo_name": "mit-ll/radar-intro", "max_issues_repo_head_hexsha": "9ff2ac5d263c9ceddafed320a65396fb8258fb32", "max_issues_repo_licenses": ["FSFULLR", "FSFUL"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "rad/quiz.py", "max_forks_repo_name": "mit-ll/radar-intro", "max_forks_repo_head_hexsha": "9ff2ac5d263c9ceddafed320a65396fb8258fb32", "max_forks_repo_licenses": ["FSFULLR", "FSFUL"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.6825396825, "max_line_length": 103, "alphanum_fraction": 0.6010289389, "include": true, "reason": "import numpy", "num_tokens": 6048, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4416729909662417, "lm_q2_score": 0.1688569500503904, "lm_q1q2_score": 0.0745795541741932}}
{"text": "# Importing packages and loading in the data set \nfrom utils_pos import get_word_tag, preprocess  \nimport pandas as pd\nfrom collections import defaultdict\nimport math\nimport numpy as np\n\n# load in the training corpus\nwith open(\"WSJ_02-21.pos\", 'r') as f:\n    training_corpus = f.readlines()\n\nprint(f\"A few items of the training corpus list\")\nprint(training_corpus[0:5])\n\n# read the vocabulary data, split by each line of text, and save the list\nwith open(\"hmm_vocab.txt\", 'r') as f:\n    voc_l = f.read().split('\\n')\n\nprint(\"A few items of the vocabulary list\")\nprint(voc_l[0:50])\nprint()\nprint(\"A few items at the end of the vocabulary list\")\nprint(voc_l[-50:])\n\n# vocab: dictionary that has the index of the corresponding words\nvocab = {} \n\n# Get the index of the corresponding words. \nfor i, word in enumerate(sorted(voc_l)): \n    vocab[word] = i       \n    \nprint(\"Vocabulary dictionary, key is the word, value is a unique integer\")\ncnt = 0\nfor k,v in vocab.items():\n    print(f\"{k}:{v}\")\n    cnt += 1\n    if cnt > 20:\n        break\n        \n# load in the test corpus\nwith open(\"WSJ_24.pos\", 'r') as f:\n    y = f.readlines()\n\nprint(\"A sample of the test corpus\")\nprint(y[0:10])\n\n#corpus without tags, preprocessed\n_, prep = preprocess(vocab, \"test.words\")     \n\nprint('The length of the preprocessed test corpus: ', len(prep))\nprint('This is a sample of the test_corpus: ')\nprint(prep[0:10])\n\n# Part 1: Parts-of-speech tagging\n# UNQ_C1\ndef create_dictionaries(training_corpus, vocab):\n    \"\"\"\n    Input: \n        training_corpus: a corpus where each line has a word followed by its tag.\n        vocab: a dictionary where keys are words in vocabulary and value is an index\n    Output: \n        emission_counts: a dictionary where the keys are (tag, word) and the values are the counts\n        transition_counts: a dictionary where the keys are (prev_tag, tag) and the values are the counts\n        tag_counts: a dictionary where the keys are the tags and the values are the counts\n    \"\"\"\n    \n    # initialize the dictionaries using defaultdict\n    emission_counts = defaultdict(int)\n    transition_counts = defaultdict(int)\n    tag_counts = defaultdict(int)\n    \n    # Initialize \"prev_tag\" (previous tag) with the start state, denoted by '--s--'\n    prev_tag = '--s--' \n    \n    # use 'i' to track the line number in the corpus\n    i = 0 \n    \n    # Each item in the training corpus contains a word and its POS tag\n    # Go through each word and its tag in the training corpus\n    for word_tag in training_corpus:\n        \n        # Increment the word_tag count\n        i += 1\n        \n        # Every 50,000 words, print the word count\n        if i % 50000 == 0:\n            print(f\"word count = {i}\")\n            \n        # get the word and tag using the get_word_tag helper function (imported from utils_pos.py)\n        word, tag = get_word_tag(word_tag,vocab) \n        \n        # Increment the transition count for the previous word and tag\n        transition_counts[(prev_tag, tag)] += 1\n        \n        # Increment the emission count for the tag and word\n        emission_counts[(tag, word)] += 1\n\n        # Increment the tag count\n        tag_counts[tag] += 1\n\n        # Set the previous tag to this tag (for the next iteration of the loop)\n        prev_tag = tag\n        \n    return emission_counts, transition_counts, tag_counts\n  \n  emission_counts, transition_counts, tag_counts = create_dictionaries(training_corpus, vocab)\n  \n  # get all the POS states\nstates = sorted(tag_counts.keys())\nprint(f\"Number of POS tags (number of 'states'): {len(states)}\")\nprint(\"View these POS tags (states)\")\nprint(states)\n\nprint(\"transition examples: \")\nfor ex in list(transition_counts.items())[:3]:\n    print(ex)\nprint()\n\nprint(\"emission examples: \")\nfor ex in list(emission_counts.items())[200:203]:\n    print (ex)\nprint()\n\nprint(\"ambiguous word example: \")\nfor tup,cnt in emission_counts.items():\n    if tup[1] == 'back': print (tup, cnt) \n      \n# UNQ_C2 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: predict_pos\n\ndef predict_pos(prep, y, emission_counts, vocab, states):\n    '''\n    Input: \n        prep: a preprocessed version of 'y'. A list with the 'word' component of the tuples.\n        y: a corpus composed of a list of tuples where each tuple consists of (word, POS)\n        emission_counts: a dictionary where the keys are (tag,word) tuples and the value is the count\n        vocab: a dictionary where keys are words in vocabulary and value is an index\n        states: a sorted list of all possible tags for this assignment\n    Output: \n        accuracy: Number of times you classified a word correctly\n    '''\n    \n    # Initialize the number of correct predictions to zero\n    num_correct = 0\n    \n    # Get the (tag, word) tuples, stored as a set\n    all_words = set(emission_counts.keys())\n    \n    # Get the number of (word, POS) tuples in the corpus 'y'\n    total = len(y)\n    for word, y_tup in zip(prep, y): \n\n        # Split the (word, POS) string into a list of two items\n        y_tup_l = y_tup.split()\n        \n        # Verify that y_tup contain both word and POS\n        if len(y_tup_l) == 2:\n            \n            # Set the true POS label for this word\n            true_label = y_tup_l[1]\n\n        else:\n            # If the y_tup didn't contain word and POS, go to next word\n            continue\n    \n        count_final = 0\n        pos_final = ''\n        \n        # If the word is in the vocabulary...\n        if word in vocab:\n            for pos in states:\n\n            ### START CODE HERE (Replace instances of 'None' with your code) ###\n                        \n                # define the key as the tuple containing the POS and word\n                key = (pos, word)\n\n                # check if the (pos, word) key exists in the emission_counts dictionary\n                if key in emission_counts.keys(): # complete this line\n\n                # get the emission count of the (pos,word) tuple \n                    count = emission_counts.get(key,0)\n\n                    # keep track of the POS with the largest count\n                    if count>count_final: # complete this line\n\n                        # update the final count (largest count)\n                        count_final = count\n\n                        # update the final POS\n                        pos_final = pos\n\n            # If the final POS (with the largest count) matches the true POS:\n            if pos_final==true_label: # complete this line\n                \n                # Update the number of correct predictions\n                num_correct += 1\n            \n    ### END CODE HERE ###\n    accuracy = num_correct / total\n    \n    return accuracy\n\naccuracy_predict_pos = predict_pos(prep, y, emission_counts, vocab, states)\nprint(f\"Accuracy of prediction using predict_pos is {accuracy_predict_pos:.4f}\")\n\n# UNQ_C3\ndef create_transition_matrix(alpha, tag_counts, transition_counts):\n    ''' \n    Input: \n        alpha: number used for smoothing\n        tag_counts: a dictionary mapping each tag to its respective count\n        transition_counts: transition count for the previous word and tag\n    Output:\n        A: matrix of dimension (num_tags,num_tags)\n    '''\n    # Get a sorted list of unique POS tags\n    all_tags = sorted(tag_counts.keys())\n    \n    # Count the number of unique POS tags\n    num_tags = len(all_tags)\n    \n    # Initialize the transition matrix 'A'\n    A = np.zeros((num_tags,num_tags))\n    \n    # Get the unique transition tuples (previous POS, current POS)\n    trans_keys = set(transition_counts.keys())\n    \n    # Go through each row of the transition matrix A\n    for i in range(num_tags):\n        \n        # Go through each column of the transition matrix A\n        for j in range(num_tags):\n\n            # Initialize the count of the (prev POS, current POS) to zero\n            count = 0\n        \n            # Define the tuple (prev POS, current POS)\n            # Get the tag at position i and tag at position j (from the all_tags list)\n            key = (all_tags[i], all_tags[j])\n\n            # Check if the (prev POS, current POS) tuple \n            # exists in the transition counts dictionary\n            if key in trans_keys: #complete this line\n                \n                # Get count from the transition_counts dictionary \n                # for the (prev POS, current POS) tuple\n                count = transition_counts.get(key,0)\n                \n            # Get the count of the previous tag (index position i) from tag_counts\n            count_prev_tag = tag_counts.get(all_tags[i],0)\n            \n            # Apply smoothing using count of the tuple, alpha, \n            # count of previous tag, alpha, and total number of tags\n            A[i,j] = (count + alpha)/(count_prev_tag+num_tags*alpha)\n    \n    return A\n  \nalpha = 0.001\nA = create_transition_matrix(alpha, tag_counts, transition_counts)\n# Testing your function\nprint(f\"A at row 0, col 0: {A[0,0]:.9f}\")\nprint(f\"A at row 3, col 1: {A[3,1]:.4f}\")\n\nprint(\"View a subset of transition matrix A\")\nA_sub = pd.DataFrame(A[30:35,30:35], index=states[30:35], columns = states[30:35] )\nprint(A_sub)\n\n# UNQ_C4\ndef create_emission_matrix(alpha, tag_counts, emission_counts, vocab):\n    '''\n    Input: \n        alpha: tuning parameter used in smoothing \n        tag_counts: a dictionary mapping each tag to its respective count\n        emission_counts: a dictionary where the keys are (tag, word) and the values are the counts\n        vocab: a dictionary where keys are words in vocabulary and value is an index.\n               within the function it'll be treated as a list\n    Output:\n        B: a matrix of dimension (num_tags, len(vocab))\n    '''\n    \n    # get the number of POS tag\n    num_tags = len(tag_counts)\n    \n    # Get a list of all POS tags\n    all_tags = sorted(tag_counts.keys())\n    \n    # Get the total number of unique words in the vocabulary\n    num_words = len(vocab)\n    \n    # Initialize the emission matrix B with places for\n    # tags in the rows and words in the columns\n    B = np.zeros((num_tags, num_words))\n    \n    # Get a set of all (POS, word) tuples \n    # from the keys of the emission_counts dictionary\n    emis_keys = set(list(emission_counts.keys()))\n    \n    # Go through each row (POS tags)\n    for i in range(num_tags): # complete this line\n        \n        # Go through each column (words)\n        for j in range(num_words): # complete this line\n\n            # Initialize the emission count for the (POS tag, word) to zero\n            count = 0\n                    \n            # Define the (POS tag, word) tuple for this row and column\n            key =  (all_tags[i], vocab[j])\n\n            # check if the (POS tag, word) tuple exists as a key in emission counts\n            if key in emis_keys: # complete this line\n        \n                # Get the count of (POS tag, word) from the emission_counts d\n                count = emission_counts[key]\n                \n            # Get the count of the POS tag\n            count_tag = tag_counts[all_tags[i]]\n                \n            # Apply smoothing and store the smoothed value \n            # into the emission matrix B for this row and column\n            B[i,j] = (count+alpha)/(count_tag+num_words*alpha)\n\n    return B\n  \n# creating your emission probability matrix. this takes a few minutes to run. \nB = create_emission_matrix(alpha, tag_counts, emission_counts, list(vocab))\n\nprint(f\"View Matrix position at row 0, column 0: {B[0,0]:.9f}\")\nprint(f\"View Matrix position at row 3, column 1: {B[3,1]:.9f}\")\n\n# Try viewing emissions for a few words in a sample dataframe\ncidx  = ['725','adroitly','engineers', 'promoted', 'synergy']\n\n# Get the integer ID for each word\ncols = [vocab[a] for a in cidx]\n\n# Choose POS tags to show in a sample dataframe\nrvals =['CD','NN','NNS', 'VB','RB','RP']\n\n# For each POS tag, get the row number from the 'states' list\nrows = [states.index(a) for a in rvals]\n\n# Get the emissions for the sample of words, and the sample of POS tags\nB_sub = pd.DataFrame(B[np.ix_(rows,cols)], index=rvals, columns = cidx )\nprint(B_sub)\n\n# Part 3: Viterbi Algorithm and Dynamic Programming\n# UNQ_C5\ndef initialize(states, tag_counts, A, B, corpus, vocab):\n    '''\n    Input: \n        states: a list of all possible parts-of-speech\n        tag_counts: a dictionary mapping each tag to its respective count\n        A: Transition Matrix of dimension (num_tags, num_tags)\n        B: Emission Matrix of dimension (num_tags, len(vocab))\n        corpus: a sequence of words whose POS is to be identified in a list \n        vocab: a dictionary where keys are words in vocabulary and value is an index\n    Output:\n        best_probs: matrix of dimension (num_tags, len(corpus)) of floats\n        best_paths: matrix of dimension (num_tags, len(corpus)) of integers\n    '''\n    # Get the total number of unique POS tags\n    num_tags = len(tag_counts)\n    \n    # Initialize best_probs matrix \n    # POS tags in the rows, number of words in the corpus as the columns\n    best_probs = np.zeros((num_tags, len(corpus)))\n    \n    # Initialize best_paths matrix\n    # POS tags in the rows, number of words in the corpus as columns\n    best_paths = np.zeros((num_tags, len(corpus)), dtype=int)\n    \n    # Define the start token\n    s_idx = states.index(\"--s--\")\n    \n    # Go through each of the POS tags\n    for i in range(num_tags): # complete this line\n        \n        # Handle the special case when the transition from start token to POS tag i is zero\n        if A[s_idx,i]==0: # complete this line\n            \n            # Initialize best_probs at POS tag 'i', column 0, to negative infinity\n            best_probs[i,0] = float('-inf')\n        \n        # For all other cases when transition from start token to POS tag i is non-zero:\n        else:\n            \n            # Initialize best_probs at POS tag 'i', column 0\n            # Check the formula in the instructions above\n            best_probs[i,0] = math.log(A[s_idx,i]) + math.log(B[i,vocab[corpus[0]]]) \n\n    return best_probs, best_paths\n  \n  \nbest_probs, best_paths = initialize(states, tag_counts, A, B, prep, vocab)\n# Test the function\nprint(f\"best_probs[0,0]: {best_probs[0,0]:.4f}\") \nprint(f\"best_paths[2,3]: {best_paths[2,3]:.4f}\")\n\n# UNQ_C6\ndef viterbi_forward(A, B, test_corpus, best_probs, best_paths, vocab):\n    '''\n    Input: \n        A, B: The transition and emission matrices respectively\n        test_corpus: a list containing a preprocessed corpus\n        best_probs: an initilized matrix of dimension (num_tags, len(corpus))\n        best_paths: an initilized matrix of dimension (num_tags, len(corpus))\n        vocab: a dictionary where keys are words in vocabulary and value is an index \n    Output: \n        best_probs: a completed matrix of dimension (num_tags, len(corpus))\n        best_paths: a completed matrix of dimension (num_tags, len(corpus))\n    '''\n    # Get the number of unique POS tags (which is the num of rows in best_probs)\n    num_tags = best_probs.shape[0]\n    \n    # Go through every word in the corpus starting from word 1\n    # Recall that word 0 was initialized in `initialize()`\n    for i in range(1, len(test_corpus)): \n        \n        # Print number of words processed, every 5000 words\n        if i % 5000 == 0:\n            print(\"Words processed: {:>8}\".format(i))\n\n        # For each unique POS tag that the current word can be\n        for j in range(num_tags): # complete this line\n            \n            # Initialize best_prob for word i to negative infinity\n            best_prob_i = float('-inf')\n            \n            # Initialize best_path for current word i to None\n            best_path_i = None\n\n            # For each POS tag that the previous word can be:\n            for k in range(num_tags): # complete this line\n            \n                # Calculate the probability = \n                # best probs of POS tag k, previous word i-1 + \n                # log(prob of transition from POS k to POS j) + \n                # log(prob that emission of POS j is word i)\n                prob = best_probs[k,i-1] + math.log(A[k,j]) + math.log(B[j,vocab[test_corpus[i]]])\n\n                # check if this path's probability is greater than\n                # the best probability up to and before this point\n                if prob > best_prob_i: # complete this line\n                    \n                    # Keep track of the best probability\n                    best_prob_i = prob\n                    \n                    # keep track of the POS tag of the previous word\n                    # that is part of the best path.  \n                    # Save the index (integer) associated with \n                    # that previous word's POS tag\n                    best_path_i = k\n\n            # Save the best probability for the \n            # given current word's POS tag\n            # and the position of the current word inside the corpus\n            best_probs[j,i] = best_prob_i\n            \n            # Save the unique integer ID of the previous POS tag\n            # into best_paths matrix, for the POS tag of the current word\n            # and the position of the current word inside the corpus.\n            best_paths[j,i] = best_path_i\n\n    return best_probs, best_paths\n  \n  \n# this will take a few minutes to run => processes ~ 30,000 words\nbest_probs, best_paths = viterbi_forward(A, B, prep, best_probs, best_paths, vocab)\n\n# Test this function \nprint(f\"best_probs[0,1]: {best_probs[0,1]:.4f}\") \nprint(f\"best_probs[0,4]: {best_probs[0,4]:.4f}\") \n\n# UNQ_C7\n# UNQ_C7 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: viterbi_backward\ndef viterbi_backward(best_probs, best_paths, corpus, states):\n    '''\n    This function returns the best path.\n    \n    '''\n    # Get the number of words in the corpus\n    # which is also the number of columns in best_probs, best_paths\n    m = best_paths.shape[1] \n    \n    # Initialize array z, same length as the corpus\n    z = [None] * m\n    \n    # Get the number of unique POS tags\n    num_tags = best_probs.shape[0]\n    \n    # Initialize the best probability for the last word\n    best_prob_for_last_word = float('-inf')\n    \n    # Initialize pred array, same length as corpus\n    pred = [None] * m\n    \n    ## Step 1 ##\n    \n    # Go through each POS tag for the last word (last column of best_probs)\n    # in order to find the row (POS tag integer ID) \n    # with highest probability for the last word\n    for k in range(num_tags): # complete this line\n\n        # If the probability of POS tag at row k \n        # is better than the previously best probability for the last word:\n        if best_probs[k,-1] > best_prob_for_last_word: # complete this line\n            \n            # Store the new best probability for the last word\n            best_prob_for_last_word = best_probs[k,m-1]\n    \n            # Store the unique integer ID of the POS tag\n            # which is also the row number in best_probs\n            z[m - 1] = k\n            \n    # Convert the last word's predicted POS tag\n    # from its unique integer ID into the string representation\n    # using the 'states' list\n    # store this in the 'pred' array for the last word\n    pred[m - 1] = states[k]\n    \n    ## Step 2 ##\n    # Find the best POS tags by walking backward through the best_paths\n    # From the last word in the corpus to the 0th word in the corpus\n    for i in range(m-1, -1, -1): # complete this line\n        \n        # Retrieve the unique integer ID of\n        # the POS tag for the word at position 'i' in the corpus\n        pos_tag_for_word_i = z[i]\n        \n        # In best_paths, go to the row representing the POS tag of word i\n        # and the column representing the word's position in the corpus\n        # to retrieve the predicted POS for the word at position i-1 in the corpus\n        z[i - 1] = best_paths[pos_tag_for_word_i,i]\n        \n        # Get the previous word's POS tag in string form\n        # Use the 'states' list, \n        # where the key is the unique integer ID of the POS tag,\n        # and the value is the string representation of that POS tag\n        pred[i - 1] = states[z[i - 1]]\n\n    return pred\n  \n# Run and test your function\npred = viterbi_backward(best_probs, best_paths, prep, states)\nm=len(pred)\nprint('The prediction for pred[-7:m-1] is: \\n', prep[-7:m-1], \"\\n\", pred[-7:m-1], \"\\n\")\nprint('The prediction for pred[0:8] is: \\n', pred[0:7], \"\\n\", prep[0:7])\n\nprint('The third word is:', prep[3])\nprint('Your prediction is:', pred[3])\nprint('Your corresponding label y is: ', y[3])\n\n# UNQ_C8\n# UNQ_C8 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: compute_accuracy\ndef compute_accuracy(pred, y):\n    '''\n    Input: \n        pred: a list of the predicted parts-of-speech \n        y: a list of lines where each word is separated by a '\\t' (i.e. word \\t tag)\n    Output: \n        \n    '''\n    num_correct = 0\n    total = 0\n    \n    # Zip together the prediction and the labels\n    for prediction, y in zip(pred, y):\n        # Split the label into the word and the POS tag\n        word_tag_tuple = y.split()\n        \n        # Check that there is actually a word and a tag\n        # no more and no less than 2 items\n        if len(word_tag_tuple) != 2: # complete this line\n            continue \n\n        #print(word_tag_tuple)\n        # store the word and tag separately\n        word, tag = word_tag_tuple\n        \n        # Check if the POS tag label matches the prediction\n        if prediction==tag: # complete this line\n            \n            # count the number of times that the prediction\n            # and label match\n            num_correct += 1\n            \n        # keep track of the total number of examples (that have valid labels)\n        total += 1\n\n    return num_correct/total\n  \nprint(f\"Accuracy of the Viterbi algorithm is {compute_accuracy(pred, y):.4f}\")\n\n", "meta": {"hexsha": "c80f3ebc8f9ce8c35af4c025f1d20b3857506e79", "size": 21835, "ext": "py", "lang": "Python", "max_stars_repo_path": "part_of_speech_tagging/pos_tagging.py", "max_stars_repo_name": "junyaogz/pp4nlp", "max_stars_repo_head_hexsha": "9f403352dcce1874d32ba775a02cbacda0904966", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "part_of_speech_tagging/pos_tagging.py", "max_issues_repo_name": "junyaogz/pp4nlp", "max_issues_repo_head_hexsha": "9f403352dcce1874d32ba775a02cbacda0904966", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "part_of_speech_tagging/pos_tagging.py", "max_forks_repo_name": "junyaogz/pp4nlp", "max_forks_repo_head_hexsha": "9f403352dcce1874d32ba775a02cbacda0904966", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.5133779264, "max_line_length": 104, "alphanum_fraction": 0.6229906114, "include": true, "reason": "import numpy", "num_tokens": 5233, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4225046348141882, "lm_q2_score": 0.1755380649971796, "lm_q1q2_score": 0.0741656460476226}}
{"text": "# -*- coding: utf-8 -*-\n\"\"\"\n`torch.nn` 이 *실제로* 무엇인가요?\n=====================================\n저자: Jeremy Howard, `fast.ai <https://www.fast.ai>`_.\n\n도움: Rachel Thomas, Francisco Ingham.\n\n번역: `남상호 <https://github.com/namdori61>`_\n\n\"\"\"\n\n###############################################################################\n# 이 튜토리얼을 스크립트가 아닌 노트북으로 실행하기를 권장합니다. 노트북 (.ipynb) 파일을 다운 받으시려면,\n# 페이지 상단에 있는 링크를 클릭해주세요.\n#\n# PyTorch 는 여러분이 신경망(neural network)를 생성하고 학습시키는 것을 도와주기 위해서\n# `torch.nn <https://pytorch.org/docs/stable/nn.html>`_ ,\n# `torch.optim <https://pytorch.org/docs/stable/optim.html>`_ ,\n# `Dataset <https://pytorch.org/docs/stable/data.html?highlight=dataset#torch.utils.data.Dataset>`_ ,\n# 그리고 `DataLoader <https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader>`_\n# 와 같은 잘 디자인된 모듈과 클래스들을 제공합니다.\n# 이들의 성능을 최대한 활용하고 여러분의 문제에 맞게 커스터마이즈하기 위해서,\n# 정확히 이들이 어떤 작업을 수행하는지 이해할 필요가 있습니다.\n# 이해를 증진하기 위해서, 우리는 먼저 이들 모델들로 부터 아무 피쳐도 사용하지 않고\n# MNIST 데이터셋에 대해 기초적인 신경망을 학습시킬 것입니다;\n# 우리는 처음에는 가장 기초적인 PyTorch 텐서(tensor) 기능만을 사용할 것입니다.\n# 그리고나서 우리는 점차적으로 ``torch.nn``, ``torch.optim``, ``Dataset``, 또는\n# ``DataLoader`` 로부터 한번에 하나씩 피쳐를 추가하면서, 정확히 각 부분이 어떤 일을 하는지 그리고\n# 이것이 어떻게 코드를 더 정확하고 유연하게 만드는지 보여줄 것입니다.\n#\n# **이 튜토리얼은 여러분이 이미 PyTorch를 설치하였고, 그리고 텐서 연산의 기초에 대해 익숙하다고 가정합니다.**\n# (만약 여러분이 Numpy 배열(array) 연산에 익숙하다면, 여기에서 사용되는 PyTorch 텐서 연산도\n# 거의 동일하다는 것을 알게 될 것입니다).\n#\n# MNIST 데이터 준비\n# -------------------\n#\n# 우리는 손으로 쓴 숫자(0에서 9 사이)의 흑백 이미지로 구성된 클래식\n# `MNIST <http://deeplearning.net/data/mnist/>`_ 데이터셋을 사용할 것 입니다.\n#\n# 우리는 경로 설정을 담당하는 (Python3 표준 라이브러리의 일부인)\n# `pathlib <https://docs.python.org/3/library/pathlib.html>`_ 을 사용할 것이고,\n# `requests <http://docs.python-requests.org/en/master/>`_ 를 이용하여\n# 데이터셋을 다운로드 할 것입니다. 우리는 모듈을 사용할 때만 임포트(import) 할 것이므로,\n# 여러분은 매 포인트마다 정확히 어떤 것이 사용되는지 확인할 수 있습니다.\n\nfrom pathlib import Path\nimport requests\n\nDATA_PATH = Path(\"data\")\nPATH = DATA_PATH / \"mnist\"\n\nPATH.mkdir(parents=True, exist_ok=True)\n\nURL = \"https://github.com/pytorch/tutorials/raw/master/_static/\"\nFILENAME = \"mnist.pkl.gz\"\n\nif not (PATH / FILENAME).exists():\n        content = requests.get(URL + FILENAME).content\n        (PATH / FILENAME).open(\"wb\").write(content)\n\n###############################################################################\n# 이 데이터셋은 numpy 배열 포맷이고, 데이터를 직렬화하기 위한\n# python 전용 포맷 pickle 을 이용하여 저장되어 있습니다.\n\nimport pickle\nimport gzip\n\nwith gzip.open((PATH / FILENAME).as_posix(), \"rb\") as f:\n        ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding=\"latin-1\")\n\n###############################################################################\n# 각 이미지는 28 x 28 형태 이고, 784 (=28x28) 크기를 가진 하나의 행으로 저장되어 있습니다.\n# 하나를 살펴 봅시다; 먼저 우리는 이 이미지를 2d로 재구성해야 합니다.\n\nfrom matplotlib import pyplot\nimport numpy as np\n\npyplot.imshow(x_train[0].reshape((28, 28)), cmap=\"gray\")\nprint(x_train.shape)\n\n###############################################################################\n# PyTorch는 numpy 배열 보다는 ``torch.tensor`` 를 사용하므로, 우리는 데이터를 변환해야 합니다.\n\nimport torch\n\nx_train, y_train, x_valid, y_valid = map(\n    torch.tensor, (x_train, y_train, x_valid, y_valid)\n)\nn, c = x_train.shape\nx_train, x_train.shape, y_train.min(), y_train.max()\nprint(x_train, y_train)\nprint(x_train.shape)\nprint(y_train.min(), y_train.max())\n\n###############################################################################\n# torch.nn 없이 밑바닥부터 신경망 만들기\n# ---------------------------------------------\n#\n# PyTorch 텐서 연산만으로 첫 모델을 만들어봅시다.\n# 여러분이 신경망의 기초에 대해서 이미 익숙하다고 가정합니다.\n# (만약 익숙하지 않다면 `course.fast.ai <https://course.fast.ai>`_ 에서 학습할 수 있습니다).\n#\n# PyTorch는 랜덤 또는 0으로만 이루어진 텐서를 생성하는 메서드를 제공하고,\n# 우리는 간단한 선형 모델의 가중치(weights)와 절편(bias)을 생성하기 위해서 이것을 사용할 것입니다.\n# 이들은 일반적인 텐서에 매우 특별한 한 가지가 추가된 것입니다: 우리는 PyTorch에게 이들이\n# 기울기(gradient)가 필요하다고 알려줍니다.\n# 이를 통해 PyTorch는 텐서에 행해지는 모든 연산을 기록하게 하고,\n# 따라서 *자동적으로* 역전파(back-propagation) 동안에 기울기를 계산할 수 있습니다!\n#\n# 가중치에 대해서는 ``requires_grad`` 를 초기화(initialization) **다음에** 설정합니다,\n# 왜냐하면 우리는 해당 단계가 기울기에 포함되는 것을 원치 않기 때문입니다.\n# (PyTorch에서 ``_`` 다음에 오는 메서드 이름은 연산이 인플레이스(in-place)로 수행되는 것을 의미합니다.)\n#\n# .. note:: `Xavier initialisation <http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf>`_\n#    기법을 이용하여 가중치를 초기화 합니다. (1/sqrt(n)을 곱해주는 것을 통해서 초기화).\n\nimport math\n\nweights = torch.randn(784, 10) / math.sqrt(784)\nweights.requires_grad_()\nbias = torch.zeros(10, requires_grad=True)\n\n###############################################################################\n# PyTorch의 기울기를 자동으로 계산해주는 기능 덕분에, Python 표준 함수\n# (또는 호출 가능한 객체)를 모델로 사용할 수 있습니다!\n# 그러므로 간단한 선형 모델을 만들기 위해서 단순한 행렬 곱셈과 브로드캐스트(broadcast)\n# 덧셈을 사용하여 보겠습니다. 또한, 우리는 활성화 함수(activation function)가 필요하므로,\n# `log_softmax` 를 구현하고 사용할 것입니다.\n# PyTorch에서 많은 사전 구현된 손실 함수(loss function), 활성화 함수들이 제공되지만,\n# 일반적인 python을 사용하여 자신만의 함수를 쉽게 작성할 수 있음을 기억해주세요.\n# PyTorch는 심지어 여러분의 함수를 위해서 빠른 GPU 또는 벡터화된 CPU 코드를 만들어줄 것입니다.\n\ndef log_softmax(x):\n    return x - x.exp().sum(-1).log().unsqueeze(-1)\n\ndef model(xb):\n    return log_softmax(xb @ weights + bias)\n\n###############################################################################\n# 위에서, ``@`` 기호는 점곱(dot product) 연산을 나타냅니다.\n# 우리는 하나의 배치(batch) 데이터(이 경우에는 64개의 이미지들)에 대하여 함수를 호출할 것입니다.\n# 이것은 하나의 *포워드 전달(forward pass)* 입니다. 이 단계에서 우리는 무작위(random) 가중치로\n# 시작했기 때문에 우리의 예측이 무작위 예측보다 전혀 나은 점이 없을 것입니다.\n\nbs = 64  # 배치 사이즈\n\nxb = x_train[0:bs]  # x로부터 미니배치(mini-batch) 추출\npreds = model(xb)  # 예측\npreds[0], preds.shape\nprint(preds[0], preds.shape)\n\n###############################################################################\n# 여러분이 보시듯이, ``preds`` 텐서(tensor)는 텐서 값 외에도, 또한\n# 기울기 함수(gradient function)를 담고 있습니다.\n# 우리는 나중에 이것을 역전파(backpropagation)를 위해 사용할 것입니다.\n# 이제 손실함수(loss function)로 사용하기 위한 음의 로그 우도(negative log-likelihood)를\n# 구현합시다. (다시 말하지만, 우리는 표준 Python을 사용할 수 있습니다.):\n\n\ndef nll(input, target):\n    return -input[range(target.shape[0]), target].mean()\n\nloss_func = nll\n\n###############################################################################\n# 우리의 무작위 모델에 대한 손실을 점검해봅시다, 그럼으로써 우리는 나중에 역전파 이후에 개선이 있는지\n# 확인할 수 있습니다.\n\nyb = y_train[0:bs]\nprint(loss_func(preds, yb))\n\n\n###############################################################################\n# 또한, 우리 모델의 정확도(accuracy)를 계산하기 위한 함수를 구현합시다.\n# 매 예측마다, 만약 가장 큰 값의 인덱스가 목표값(target value)과 동일하다면,\n# 그 예측은 올바른 것입니다.\n\ndef accuracy(out, yb):\n    preds = torch.argmax(out, dim=1)\n    return (preds == yb).float().mean()\n\n###############################################################################\n# 우리의 무작위 모델의 정확도를 점검해 봅시다, 그럼으로써 손실이 개선됨에 따라서 정확도가 개선되는지\n# 확인할 수 있습니다.\n\nprint(accuracy(preds, yb))\n\n###############################################################################\n# 이제 우리는 훈련 루프(training loop)를 실행할 수 있습니다. 매 반복마다, 우리는 다음을 수행할 것입니다:\n#\n# - 데이터의 미니배치를 선택 (``bs`` 사이즈)\n# - 모델을 이용하여 예측 수행\n# - 손실 계산\n# - ``loss.backward()`` 를 이용하여 모델의 기울기 업데이트, 이 경우에는, ``weights`` 와 ``bias``.\n#\n# 이제 우리는 이 기울기들을 이용하여 가중치와 절편을 업데이트 합니다.\n# 우리는 이것을 ``torch.no_grad()`` 컨텍스트 매니져(context manager) 내에서 실행합니다,\n# 왜냐하면 이러한 실행이 다음 기울기의 계산에 기록되지 않기를 원하기 때문입니다.\n# PyTorch의 자동 기울기(Autograd)가 어떻게 연산을 기록하는지\n# `여기 <https://pytorch.org/docs/stable/notes/autograd.html>`_ 에서 더 알아볼 수 있습니다.\n#\n# 우리는 그러고나서 기울기를 0으로 설정합니다, 그럼으로써 다음 루프(loop)에 준비하게 됩니다.\n# 그렇지 않으면, 우리의 기울기들은 일어난 모든 연산의 누적 집계를 기록하게 되버립니다.\n# (즉, ``loss.backward()`` 가 이미 저장된 것을 대체하기보단, 기존 값에 기울기를 *더하게* 됩니다).\n#\n# .. tip:: 여러분들은 PyTorch 코드에 대하여 표준 python 디버거(debugger)를 사용할 수 있으므로,\n#    매 단계마다 다양한 변수 값을 점검할 수 있습니다.\n#    아래에서 ``set_trace()`` 를 주석 해제하여 사용해보세요.\n#\n\nfrom IPython.core.debugger import set_trace\n\nlr = 0.5  # 학습률(learning rate)\nepochs = 2  # 훈련에 사용할 에포크(epoch) 수\n\nfor epoch in range(epochs):\n    for i in range((n - 1) // bs + 1):\n        #         set_trace()\n        start_i = i * bs\n        end_i = start_i + bs\n        xb = x_train[start_i:end_i]\n        yb = y_train[start_i:end_i]\n        pred = model(xb)\n        loss = loss_func(pred, yb)\n\n        loss.backward()\n        with torch.no_grad():\n            weights -= weights.grad * lr\n            bias -= bias.grad * lr\n            weights.grad.zero_()\n            bias.grad.zero_()\n\n###############################################################################\n# 이제 다 됐습니다: 우리는 제일 간단한 신경망(neural network)의 모든 것을 밑바닥부터 생성하고\n# 훈련하였습니다! (이번에는 은닉층(hidden layer)이 없기 때문에,\n# 로지스틱 회귀(logistic regression)입니다).\n#\n# 이제 손실과 정확도를 이전 값들과 비교하면서 확인해봅시다.\n# 우리는 손실은 감소하고, 정확도는 증가하기를 기대할 것이고, 그들은 아래와 같습니다.\n\nprint(loss_func(model(xb), yb), accuracy(model(xb), yb))\n\n###############################################################################\n# torch.nn.functional 사용하기\n# ------------------------------\n#\n# 이제 우리는 코드를 리팩토링(refactoring) 하겠습니다, 그럼으로써 이전과 동일하지만,\n# PyTorch의 ``nn`` 클래스의 장점을 활용하여 더 간결하고 유연하게 만들 것입니다.\n# 지금부터 매 단계에서, 우리는 코드를 더 짧고, 이해하기 쉽고, 유연하게 만들어야 합니다.\n#\n# 처음이면서 우리의 코드를 짧게 만들기 가장 쉬운 단계는 직접 작성한 활성화, 손실 함수를\n# ``torch.nn.functional`` 의 함수로 대체하는 것입니다\n# (관례에 따라, 일반적으로 ``F`` 네임스페이스(namespace)를 통해 임포트(import) 합니다).\n# 이 모듈에는 ``torch.nn`` 라이브러리의 모든 함수가 포함되어 있습니다\n# (라이브러리의 다른 부분에는 클래스가 포함되어 있습니다.)\n# 다양한 손실 및 활성화 함수 뿐만 아니라, 풀링(pooling) 함수와 같이 신경망을 만드는데\n# 편리한 몇 가지 함수도 여기에서 찾을 수 있습니다.\n# (컨볼루션(convolution) 연산, 선형(linear) 레이어, 등을 수행하는 함수도 있지만,\n# 앞으로 보시겠지만 일반적으로 라이브러리의 다른 부분을 사용하여 더 잘 처리 할 수 있습니다.)\n#\n# 만약 여러분들이 음의 로그 우도 손실과 로그 소프트맥스 (log softmax) 활성화 함수를 사용하는 경우,\n# Pytorch는 이 둘을 결합하는 단일 함수인 ``F.cross_entropy`` 를 제공합니다.\n# 따라서 모델에서 활성화 함수를 제거할 수도 있습니다.\n\nimport torch.nn.functional as F\n\nloss_func = F.cross_entropy\n\ndef model(xb):\n    return xb @ weights + bias\n\n###############################################################################\n# 더이상 ``model`` 함수에서 ``log_softmax`` 를 호출하지 않고 있습니다.\n# 손실과 정확도과 이전과 동일한지 확인해봅시다:\n\nprint(loss_func(model(xb), yb), accuracy(model(xb), yb))\n\n###############################################################################\n# nn.Module 을 이용하여 리팩토링 하기\n# --------------------------------------\n# 다음으로, 더 명확하고 간결한 훈련 루프를 위해 ``nn.Module`` 및 ``nn.Parameter`` 를 사용합니다.\n# 우리는 ``nn.Module`` (자체가 클래스이고 상태를 추척할 수 있는) 하위 클래스(subclass)를 만듭니다.\n# 이 경우에는, 포워드(forward) 단계에 대한 가중치, 절편, 그리고 메소드(method) 등을 유지하는\n# 클래스를 만들고자 합니다.\n# ``nn.Module`` 은 우리가 사용할 몇 가지 속성(attribute)과 메소드를 (``.parameters()`` 와\n# ``.zero_grad()`` 같은) 가지고 있습니다.\n#\n# .. note:: ``nn.Module`` (대문자 M) 은 PyTorch 의 특정 개념이고, 우리는 이 클래스를\n#    많이 사용할 것입니다. ``nn.Module`` 를 Python 의 코드를 임포트하기 위한 코드 파일인\n#    `module <https://docs.python.org/3/tutorial/modules.html>`_ (소문자 ``m``)\n#    의 개념과 헷갈리지 말아주세요.\n\nfrom torch import nn\n\nclass Mnist_Logistic(nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.weights = nn.Parameter(torch.randn(784, 10) / math.sqrt(784))\n        self.bias = nn.Parameter(torch.zeros(10))\n\n    def forward(self, xb):\n        return xb @ self.weights + self.bias\n\n###############################################################################\n# 함수를 사용하는 대신에 이제는 오브젝트(object) 를 사용하기 때문에,\n# 먼저 모델을 인스턴스화(instantiate) 해야 합니다:\n\nmodel = Mnist_Logistic()\n\n###############################################################################\n# 이제 우리는 이전과 동일한 방식으로 손실을 계산할 수 있습니다.\n# 여기서 ``nn.Module`` 오브젝트들은 마치 함수처럼 사용됩니다 (즉, 이들은 *호출가능* 합니다),\n# 그러나 배후에서 Pytorch 는 우리의 ``forward`` 메소드를 자동으로 호출합니다.\n\nprint(loss_func(model(xb), yb))\n\n###############################################################################\n# 이전에는 훈련 루프를 위해 이름 별로 각 매개변수(parameter)의 값을 업데이트하고 다음과 같이\n# 각 매개 변수에 대한 기울기들을 개별적으로 수동으로 0으로 제거해야 했습니다:\n#\n# ::\n#\n#   with torch.no_grad():\n#       weights -= weights.grad * lr\n#       bias -= bias.grad * lr\n#       weights.grad.zero_()\n#       bias.grad.zero_()\n#\n#\n# 이제 우리는 model.parameters() 및 model.zero_grad() (모두\n# ``nn.Module`` 에 대해 PyTorch에 의해 정의됨)를 활용하여 이러한 단계를 더 간결하게\n# 만들고, 특히 더 복잡한 모델에 대해서 일부 매개변수를 잊어 버리는 오류를 덜 발생시킬 수 있습니다:\n#\n# ::\n#\n#   with torch.no_grad():\n#       for p in model.parameters(): p -= p.grad * lr\n#       model.zero_grad()\n#\n#\n# 이제 이것을 나중에 다시 실행할 수 있도록 ``fit`` 함수로 작은 훈련 루프를 감쌀 것입니다.\n\ndef fit():\n    for epoch in range(epochs):\n        for i in range((n - 1) // bs + 1):\n            start_i = i * bs\n            end_i = start_i + bs\n            xb = x_train[start_i:end_i]\n            yb = y_train[start_i:end_i]\n            pred = model(xb)\n            loss = loss_func(pred, yb)\n\n            loss.backward()\n            with torch.no_grad():\n                for p in model.parameters():\n                    p -= p.grad * lr\n                model.zero_grad()\n\nfit()\n\n###############################################################################\n# 손실이 줄어들었는지 다시 한번 확인합시다:\n\nprint(loss_func(model(xb), yb))\n\n###############################################################################\n# nn.Linear 를 이용하여 리팩토링 하기\n# ------------------------------------\n#\n# 계속해서 코드를 리팩토링 합니다. ``self.weights`` 및 ``self.bias`` 를 수동으로 정의 및\n# 초기화하고, ``xb  @ self.weights + self.bias`` 를 계산하는 대신에,\n# 위의 모든 것을 해줄 Pytorch 클래스인\n# `nn.Linear <https://pytorch.org/docs/stable/nn.html#linear-layers>`_ 를 선형\n# 레이어로 사용합니다.\n# Pytorch 에는 다양한 유형의 코드를 크게 단순화 할 수 있는 미리 정의된 레이어가 있고 이는 또한\n# 종종 기존 코드보다 속도를 빠르게 합니다.\n\nclass Mnist_Logistic(nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.lin = nn.Linear(784, 10)\n\n    def forward(self, xb):\n        return self.lin(xb)\n\n###############################################################################\n# 이전과 같은 방식으로 모델을 인스턴스화하고 손실을 계산합니다:\n\nmodel = Mnist_Logistic()\nprint(loss_func(model(xb), yb))\n\n###############################################################################\n# 우리는 여전히 이전과 동일한 ``fit`` 메소드를 사용할 수 있습니다.\n\nfit()\n\nprint(loss_func(model(xb), yb))\n\n###############################################################################\n# optim 을 이용하여 리팩토링 하기\n# ---------------------------------\n#\n# Pytorch에는 다양한 최적화(optimization) 알고리즘을 가진 패키지인 ``torch.optim`` 도 있습니다.\n# 각 매개변수를 수동으로 업데이트 하는 대신, 옵티마이저(optimizer)의 ``step`` 메소드를 사용하여\n# 업데이트를 진행할 수 있습니다.\n#\n# 이렇게 하면 이전에 수동으로 코딩한 최적화 단계를 대체할 수 있습니다:\n#\n# ::\n#\n#   with torch.no_grad():\n#       for p in model.parameters(): p -= p.grad * lr\n#       model.zero_grad()\n#\n# 대신에 이렇게 말이죠:\n#\n# ::\n#\n#   opt.step()\n#   opt.zero_grad()\n#\n# (``optim.zero_grad()`` 는 기울기를 0으로 재설정 해줍니다. 다음 미니 배치에 대한\n# 기울기를 계산하기 전에 호출해야 합니다.)\n\nfrom torch import optim\n\n###############################################################################\n# 나중에 다시 사용할 수 있도록 모델과 옵티마이져를 만드는 작은 함수를 정의합니다.\n\ndef get_model():\n    model = Mnist_Logistic()\n    return model, optim.SGD(model.parameters(), lr=lr)\n\nmodel, opt = get_model()\nprint(loss_func(model(xb), yb))\n\nfor epoch in range(epochs):\n    for i in range((n - 1) // bs + 1):\n        start_i = i * bs\n        end_i = start_i + bs\n        xb = x_train[start_i:end_i]\n        yb = y_train[start_i:end_i]\n        pred = model(xb)\n        loss = loss_func(pred, yb)\n\n        loss.backward()\n        opt.step()\n        opt.zero_grad()\n\nprint(loss_func(model(xb), yb))\n\n###############################################################################\n# Dataset 을 이용하여 리팩토링하기\n# ----------------------------------\n#\n# PyTorch 에는 추상 Dataset 클래스가 있습니다. Dataset 은\n# ``__len__`` 함수 (Python의 표준 ``len`` 함수에 의해 호출됨) 및\n# ``__getitem__`` 함수를 가진 어떤 것이라도 될 수 있으며, 이 함수들을 인덱싱(indexing)하기\n# 위한 방법으로 사용합니다.\n# `이 튜토리얼 <https://tutorials.pytorch.kr/beginner/data_loading_tutorial.html>`_\n# 은 ``Dataset`` 의 하위 클래스로써, 사용자 지정 ``FacialLandmarkDataset`` 클래스를 만드는\n# 좋은 예를 제시합니다.\n#\n# PyTorch 의 `TensorDataset <https://pytorch.org/docs/stable/_modules/torch/utils/data/dataset.html#TensorDataset>`_\n# 은 텐서를 감싸는(wrapping) Dataset 입니다.\n# 길이와 인덱싱 방식을 정의함으로써 텐서의 첫 번째 차원을 따라 반복, 인덱싱 및 슬라이스(slice)하는 방법도 제공합니다.\n# 이렇게하면 훈련 할 때 동일한 라인에서 독립(independent) 변수와 종속(dependent) 변수에 쉽게 액세스 할 수 있습니다.\n\nfrom torch.utils.data import TensorDataset\n\n###############################################################################\n# ``x_train`` 및 ``y_train`` 모두 하나의 ``TensorDataset`` 에 합쳐질 수 있습니다,\n# 따라서 반복시키고 슬라이스 하기 편리합니다.\n\ntrain_ds = TensorDataset(x_train, y_train)\n\n###############################################################################\n# 이전에는 x 및 y 값의 미니 배치를 별도로 반복해야했습니다:\n#\n# ::\n#\n#     xb = x_train[start_i:end_i]\n#     yb = y_train[start_i:end_i]\n#\n#\n# 이제 이 두 단계를 함께 수행 할 수 있습니다:\n#\n# ::\n#\n#     xb,yb = train_ds[i*bs : i*bs+bs]\n#\n\nmodel, opt = get_model()\n\nfor epoch in range(epochs):\n    for i in range((n - 1) // bs + 1):\n        xb, yb = train_ds[i * bs: i * bs + bs]\n        pred = model(xb)\n        loss = loss_func(pred, yb)\n\n        loss.backward()\n        opt.step()\n        opt.zero_grad()\n\nprint(loss_func(model(xb), yb))\n\n###############################################################################\n# DataLoader 를 이용하여 리팩토링하기\n# -----------------------------------\n#\n# Pytorch 의 ``DataLoader`` 는 배치 관리를 담당합니다.\n# 여러분들은 모든 ``Dataset`` 으로부터 ``DataLoader`` 를 생성할 수 있습니다.\n# ``DataLoader`` 는 배치들에 대해서 반복하기 쉽게 만들어줍니다.\n# ``train_ds[i*bs : i*bs+bs]`` 를 사용하는 대신,\n# DataLoader 는 매 미니배치를 자동적으로 제공합니다.\n\nfrom torch.utils.data import DataLoader\n\ntrain_ds = TensorDataset(x_train, y_train)\ntrain_dl = DataLoader(train_ds, batch_size=bs)\n\n###############################################################################\n# 이전에는 루프가 다음과 같이 배치 (xb, yb)를 반복했습니다:\n#\n# ::\n#\n#       for i in range((n-1)//bs + 1):\n#           xb,yb = train_ds[i*bs : i*bs+bs]\n#           pred = model(xb)\n#\n# 이제 (xb, yb)가 DataLoader 에서 자동으로 로드되므로 루프가 훨씬 깨끗해졌습니다:\n#\n# ::\n#\n#       for xb,yb in train_dl:\n#           pred = model(xb)\n\nmodel, opt = get_model()\n\nfor epoch in range(epochs):\n    for xb, yb in train_dl:\n        pred = model(xb)\n        loss = loss_func(pred, yb)\n\n        loss.backward()\n        opt.step()\n        opt.zero_grad()\n\nprint(loss_func(model(xb), yb))\n\n###############################################################################\n# Pytorch의 nn.Module, nn.Parameter, Dataset 및 DataLoader 덕분에 이제 훈련 루프가\n# 훨씬 더 작아지고 이해하기 쉬워졌습니다.\n# 이제 실제로 효과적인 모델을 만드는 데 필요한 기본 기능을 추가해 보겠습니다.\n#\n# 검증(validation) 추가하기\n# ---------------------------\n#\n# 섹션 1에서, 우리는 훈련 데이터에 사용하기 위해 합리적인 훈련 루프를 설정하려고했습니다.\n# 실전에서, 여러분들은 과적합(overfitting)을 확인하기 위해서 **항상**\n# `검증 데이터셋(validation set) <https://www.fast.ai/2017/11/13/validation-sets/>`_ 이\n# 있어야 합니다.\n#\n# 훈련 데이터를 섞는(shuffling) 것은 배치와 과적합 사이의 상관관계를 방지하기 위해\n# `중요합니다. <https://www.quora.com/Does-the-order-of-training-data-matter-when-training-neural-networks>`_\n# 반면에, 검증 손실(validation loss)은 검증 데이터셋을 섞든 안섞든 동일합니다.\n# 데이터를 섞는 것은 추가 시간이 걸리므로, 검증 데이터를 섞는 것은 의미가 없습니다.\n#\n# 검증 데이터셋에 대한 배치 사이즈는 학습 데이터셋 배치 크기의 2배를 사용할 것입니다.\n# 이는 검증 데이터셋에 대해서는 역전파(backpropagation)가 필요하지 않으므로 메모리를\n# 덜 사용하기 때문입니다 (기울기를 저장할 필요가 없음).\n# 더 큰 배치 크기를 사용하여 손실을 더 빨리 계산하기 위해 이렇게 합니다.\n\ntrain_ds = TensorDataset(x_train, y_train)\ntrain_dl = DataLoader(train_ds, batch_size=bs, shuffle=True)\n\nvalid_ds = TensorDataset(x_valid, y_valid)\nvalid_dl = DataLoader(valid_ds, batch_size=bs * 2)\n\n###############################################################################\n# 각 에포크가 끝날 때 검증 손실을 계산하고 프린트 할 것입니다.\n#\n# (훈련 전에 항상 ``model.train()`` 을 호출하고, 추론(inference) 전에 ``model.eval()``\n# 을 호출합니다, 이는 ``nn.BatchNorm2d`` 및 ``nn.Dropout`` 과 같은 레이어에서\n# 이러한 다른 단계(훈련, 추론) 에 대한 적절한 동작이 일어나게 하기 위함입니다.)\n\nmodel, opt = get_model()\n\nfor epoch in range(epochs):\n    model.train()\n    for xb, yb in train_dl:\n        pred = model(xb)\n        loss = loss_func(pred, yb)\n\n        loss.backward()\n        opt.step()\n        opt.zero_grad()\n\n    model.eval()\n    with torch.no_grad():\n        valid_loss = sum(loss_func(model(xb), yb) for xb, yb in valid_dl)\n\n    print(epoch, valid_loss / len(valid_dl))\n\n###############################################################################\n# fit() 와 get_data() 생성하기\n# ----------------------------------\n#\n# 이제 우리는 우리만의 작은 리팩토링을 수행할 것입니다.\n# 훈련 데이터셋과 검증 데이터셋 모두에 대한 손실을 계산하는 유사한 프로세스를 두 번 거치므로,\n# 이를 하나의 배치에 대한 손실을 계산하는 자체 함수 ``loss_batch`` 로 만들어보겠습니다.\n#\n# 훈련 데이터셋에 대한 옵티마이저를 전달하고 이를 사용하여 역전파를 수행합니다.\n# 검증 데이터셋의 경우 옵티마이저를 전덜하지 않으므로 메소드가 역전파를 수행하지 않습니다.\n\n\ndef loss_batch(model, loss_func, xb, yb, opt=None):\n    loss = loss_func(model(xb), yb)\n\n    if opt is not None:\n        loss.backward()\n        opt.step()\n        opt.zero_grad()\n\n    return loss.item(), len(xb)\n\n###############################################################################\n# ``fit`` 은 모델을 훈련하고 각 에포크에 대한 훈련 및 검증 손실을 계산하는 작업을 수행합니다.\n\nimport numpy as np\n\ndef fit(epochs, model, loss_func, opt, train_dl, valid_dl):\n    for epoch in range(epochs):\n        model.train()\n        for xb, yb in train_dl:\n            loss_batch(model, loss_func, xb, yb, opt)\n\n        model.eval()\n        with torch.no_grad():\n            losses, nums = zip(\n                *[loss_batch(model, loss_func, xb, yb) for xb, yb in valid_dl]\n            )\n        val_loss = np.sum(np.multiply(losses, nums)) / np.sum(nums)\n\n        print(epoch, val_loss)\n\n###############################################################################\n# ``get_data`` 는 학습 및 검증 데이터셋에 대한 dataloader 를 출력합니다.\n\n\ndef get_data(train_ds, valid_ds, bs):\n    return (\n        DataLoader(train_ds, batch_size=bs, shuffle=True),\n        DataLoader(valid_ds, batch_size=bs * 2),\n    )\n\n###############################################################################\n# 이제 dataloader를 가져오고 모델을 훈련하는 전체 프로세스를 3 줄의 코드로 실행할 수 있습니다:\n\ntrain_dl, valid_dl = get_data(train_ds, valid_ds, bs)\nmodel, opt = get_model()\nfit(epochs, model, loss_func, opt, train_dl, valid_dl)\n\n###############################################################################\n# 이러한 기본 3줄의 코드를 사용하여 다양한 모델을 훈련할 수 있습니다.\n# 컨볼루션 신경망(CNN)을 훈련하는 데 사용할 수 있는지 살펴 보겠습니다!\n#\n# CNN 으로 넘어가기\n# --------------------\n#\n# 이제 3개의 컨볼루션 레이어로 신경망을 구축할 것입니다.\n# 이전 섹션의 어떤 함수도 모델의 형식에 대해 가정하지 않기 때문에,\n# 별도의 수정없이 CNN을 학습하는 데 사용할 수 있습니다.\n#\n# Pytorch 의 사전정의된\n# `Conv2d <https://pytorch.org/docs/stable/nn.html#torch.nn.Conv2d>`_ 클래스를\n# 컨볼루션 레이어로 사용합니다. 3개의 컨볼루션 레이어로 CNN을 정의합니다.\n# 각 컨볼루션 뒤에는 ReLU가 있습니다. 마지막으로 평균 풀링(average pooling)을 수행합니다.\n# (``view`` 는 PyTorch의 numpy ``reshape`` 버전입니다.)\n\nclass Mnist_CNN(nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1)\n        self.conv2 = nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=1)\n        self.conv3 = nn.Conv2d(16, 10, kernel_size=3, stride=2, padding=1)\n\n    def forward(self, xb):\n        xb = xb.view(-1, 1, 28, 28)\n        xb = F.relu(self.conv1(xb))\n        xb = F.relu(self.conv2(xb))\n        xb = F.relu(self.conv3(xb))\n        xb = F.avg_pool2d(xb, 4)\n        return xb.view(-1, xb.size(1))\n\nlr = 0.1\n\n###############################################################################\n# `모멘텀(Momentum) <https://cs231n.github.io/neural-networks-3/#sgd>`_ 은\n# 이전 업데이트도 고려하고 일반적으로 더 빠른 훈련으로 이어지는 확률적 경사하강법(stochastic gradient descent)\n# 의 변형입니다.\n\nmodel = Mnist_CNN()\nopt = optim.SGD(model.parameters(), lr=lr, momentum=0.9)\n\nfit(epochs, model, loss_func, opt, train_dl, valid_dl)\n\n###############################################################################\n# nn.Sequential\n# ------------------------\n#\n# ``torch.nn`` 에는 코드를 간단히 사용할 수 있는 또 다른 편리한 클래스인\n# `Sequential <https://pytorch.org/docs/stable/nn.html#torch.nn.Sequential>`_\n# 이 있습니다..\n# ``Sequential`` 객체는 그 안에 포함된 각 모듈을 순차적으로 실행합니다.\n# 이것은 우리의 신경망을 작성하는 더 간단한 방법입니다.\n#\n# 이를 활용하려면 주어진 함수에서 **사용자정의 레이어(custom layer)** 를 쉽게\n# 정의할 수 있어야 합니다.\n# 예를 들어, PyTorch에는 `view` 레이어가 없으므로 우리의 신경망 용으로 만들어야 합니다.\n# ``Lambda`` 는 ``Sequential`` 로 신경망을 정의할 때 사용할 수 있는 레이어를 생성할 것입니다.\n\nclass Lambda(nn.Module):\n    def __init__(self, func):\n        super().__init__()\n        self.func = func\n\n    def forward(self, x):\n        return self.func(x)\n\n\ndef preprocess(x):\n    return x.view(-1, 1, 28, 28)\n\n###############################################################################\n# ``Sequential`` 로 생성된 모들은 간단하게 아래와 같습니다:\n\nmodel = nn.Sequential(\n    Lambda(preprocess),\n    nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1),\n    nn.ReLU(),\n    nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=1),\n    nn.ReLU(),\n    nn.Conv2d(16, 10, kernel_size=3, stride=2, padding=1),\n    nn.ReLU(),\n    nn.AvgPool2d(4),\n    Lambda(lambda x: x.view(x.size(0), -1)),\n)\n\nopt = optim.SGD(model.parameters(), lr=lr, momentum=0.9)\n\nfit(epochs, model, loss_func, opt, train_dl, valid_dl)\n\n###############################################################################\n# DataLoader 감싸기\n# -----------------------------\n#\n# 우리의 CNN은 상당히 간결하지만, MNIST에서만 작동합니다, 왜냐하면:\n#  - 입력이 28\\*28의 긴 벡터라고 가정합니다.\n#  - 최종적으로 CNN 그리드 크기는 4\\*4 라고 가정합니다. (이것은 우리가 사용한 평균 풀링 커널 크기 때문입니다.)\n#\n# 이 두 가지 가정을 제거하여 모델이 모든 2d 단일 채널(channel) 이미지에서 작동하도록 하겠습니다.\n# 먼저 초기 Lambda 레이어를 제거하고 데이터 전처리를 제네레이터(generator)로 이동시킬 수 있습니다:\n\ndef preprocess(x, y):\n    return x.view(-1, 1, 28, 28), y\n\n\nclass WrappedDataLoader:\n    def __init__(self, dl, func):\n        self.dl = dl\n        self.func = func\n\n    def __len__(self):\n        return len(self.dl)\n\n    def __iter__(self):\n        batches = iter(self.dl)\n        for b in batches:\n            yield (self.func(*b))\n\ntrain_dl, valid_dl = get_data(train_ds, valid_ds, bs)\ntrain_dl = WrappedDataLoader(train_dl, preprocess)\nvalid_dl = WrappedDataLoader(valid_dl, preprocess)\n\n###############################################################################\n# 다음으로 ``nn.AvgPool2d`` 를 ``nn.AdaptiveAvgPool2d`` 로 대체하여 우리가 가진\n# *입력* 텐서가 아니라 원하는 *출력* 텐서의 크기를 정의할 수 있습니다.\n# 결과적으로 우리 모델은 모든 크기의 입력과 함께 작동합니다.\n\nmodel = nn.Sequential(\n    nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1),\n    nn.ReLU(),\n    nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=1),\n    nn.ReLU(),\n    nn.Conv2d(16, 10, kernel_size=3, stride=2, padding=1),\n    nn.ReLU(),\n    nn.AdaptiveAvgPool2d(1),\n    Lambda(lambda x: x.view(x.size(0), -1)),\n)\n\nopt = optim.SGD(model.parameters(), lr=lr, momentum=0.9)\n\n###############################################################################\n# 한번 실행해 봅시다:\n\nfit(epochs, model, loss_func, opt, train_dl, valid_dl)\n\n###############################################################################\n# GPU 사용하기\n# ---------------\n#\n# 만약 여러분들이 운이 좋아서 CUDA 지원 GPU (대부분의 클라우드 제공 업체에서\n# 시간당 약 $0.50 에 이용할 수 있습니다) 를 사용할 수 있다면, 코드 실행 속도를 높일 수 있습니다.\n# 먼저 GPU가 Pytorch에서 작동하는지 확인합니다:\n\nprint(torch.cuda.is_available())\n\n###############################################################################\n# 그리고 이에 대한 디바이스 오브젝트를 생성합니다:\n\ndev = torch.device(\n    \"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n\n###############################################################################\n# GPU로 배치를 옮기도록 ``preprocess`` 를 업데이트 합시다:\n\n\ndef preprocess(x, y):\n    return x.view(-1, 1, 28, 28).to(dev), y.to(dev)\n\n\ntrain_dl, valid_dl = get_data(train_ds, valid_ds, bs)\ntrain_dl = WrappedDataLoader(train_dl, preprocess)\nvalid_dl = WrappedDataLoader(valid_dl, preprocess)\n\n###############################################################################\n# 마지막으로 모델을 GPU로 이동시킬 수 있습니다.\n\nmodel.to(dev)\nopt = optim.SGD(model.parameters(), lr=lr, momentum=0.9)\n\n###############################################################################\n# 이제 더 빨리 실행됩니다:\n\nfit(epochs, model, loss_func, opt, train_dl, valid_dl)\n\n###############################################################################\n# 마치면서\n# -----------------\n#\n# 이제 Pytorch를 사용하여 다양한 유형의 모델을 학습하는 데 사용할 수 있는 일반 데이터 파이프 라인과\n# 훈련 루프가 있습니다.\n# 이제 모델 학습이 얼마나 간단한지 확인하려면 `mnist_sample` 샘플 노트북을 살펴보세요.\n#\n# 물론 데이터 증강(data augmentation), 초매개변수 조정(hyperparameter tuning),\n# 훈련과정 모니터링(monitoring training), 전이 학습(transfer learning) 등과 같이\n# 추가하고 싶은 항목들이 많이 있을 것입니다.\n# 이러한 기능들은 이 튜토리얼에 표시된 것과 동일한 설계 접근 방식을 사용하여 개발된 fastai 라이브러리에서\n# 사용할 수 있으며, 모델을 더욱 발전시키려는 실무자에게 자연스러운 다음 단계를 제공합니다.\n#\n# 이 튜토리얼의 시작 부분에서 ``torch.nn``, ``torch.optim``, ``Dataset``,\n# 그리고 ``DataLoader`` 의 각 예제를 통해 설명하겠다고 이야기했었습니다.\n# 이제 위의 내용들을 요약해보겠습니다:\n#\n#  - **torch.nn**\n#\n#    + ``Module``: 함수처럼 동작하지만, 또한 상태(state) (예를 들어, 신경망의 레이어 가중치)를\n#      포함할 수 있는 호출 가능한 오브젝트를 생성합니다.\n#      이는 포함된 ``Parameter`` (들)가 어떤 것인지 알고, 모든 기울기를 0으로 설정하고 가중치\n#      업데이트 등을 위해 반복할 수 있습니다.\n#    + ``Parameter``: ``Module`` 에 역전파 동안 업데이트가 필요한 가중치가 있음을 알려주는\n#      텐서용 래퍼입니다. `requires_grad` 속성이 설정된 텐서만 업데이트 됩니다.\n#    + ``functional``: 활성화 함수, 손실 함수 등을 포함하는 모듈 (관례에 따라 일반적으로\n#      ``F`` 네임스페이스로 임포트 됩니다) 이고, 물론 컨볼루션 및 선형 레이어 등에 대해서\n#      상태를 저장하지않는(non-stateful) 버전의 레이어를 포함합니다.\n#  - ``torch.optim``: 역전파 단계에서 ``Parameter`` 의 가중치를 업데이트하는,\n#    ``SGD`` 와 같은 옵티마이저를 포함합니다.\n#  - ``Dataset``: ``TensorDataset`` 과 같이 Pytorch와 함께 제공되는 클래스를 포함하여 ``__len__`` 및\n#    ``__getitem__`` 이 있는 객체의 추상 인터페이스\n#  - ``DataLoader``: 모든 종류의 ``Dataset`` 을 기반으로 데이터의 배치들을 출력하는 반복자(iterator)를 생성합니다.\n", "meta": {"hexsha": "4a5c806d51db8f83cd0c1d9047ea2f4463a7c97e", "size": 28156, "ext": "py", "lang": "Python", "max_stars_repo_path": "docs/_downloads/fe5bd3ad8e4d3f194907d09af8bd8299/nn_tutorial.py", "max_stars_repo_name": "junhyung9985/PyTorch-tutorials-kr", "max_stars_repo_head_hexsha": "07c50e5ddfc2f118f01ecbc071a24763f9891171", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "docs/_downloads/fe5bd3ad8e4d3f194907d09af8bd8299/nn_tutorial.py", "max_issues_repo_name": "junhyung9985/PyTorch-tutorials-kr", "max_issues_repo_head_hexsha": "07c50e5ddfc2f118f01ecbc071a24763f9891171", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/_downloads/fe5bd3ad8e4d3f194907d09af8bd8299/nn_tutorial.py", "max_forks_repo_name": "junhyung9985/PyTorch-tutorials-kr", "max_forks_repo_head_hexsha": "07c50e5ddfc2f118f01ecbc071a24763f9891171", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.850678733, "max_line_length": 115, "alphanum_fraction": 0.5480537008, "include": true, "reason": "import numpy", "num_tokens": 11845, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48828339529583464, "lm_q2_score": 0.15002882054202774, "lm_q1q2_score": 0.07325658188649077}}
{"text": "\n# coding: utf-8\n\n# In[ ]:\n\n\nget_ipython().magic(u'load_ext watermark')\nget_ipython().magic(u\"watermark -d -u -a 'Andreas Mueller, Kyle Kastner, Sebastian Raschka' -v -p numpy,scipy,matplotlib\")\n\n\n# The use of watermark (above) is optional, and we use it to keep track of the changes while developing the tutorial material. (You can install this IPython extension via \"pip install watermark\". For more information, please see: https://github.com/rasbt/watermark).\n\n# # SciPy 2016 Scikit-learn Tutorial\n\n# # Representation and Visualization of Data\n\n# Machine learning is about fitting models to data; for that reason, we'll start by\n# discussing how data can be represented in order to be understood by the computer.  Along\n# with this, we'll build on our matplotlib examples from the previous section and show some\n# examples of how to visualize data.\n\n# ## Data in scikit-learn\n\n# Data in scikit-learn, with very few exceptions, is assumed to be stored as a\n# **two-dimensional array**, of shape `[n_samples, n_features]`. Many algorithms also accept ``scipy.sparse`` matrices of the same shape.\n\n# - **n_samples:**   The number of samples: each sample is an item to process (e.g. classify).\n#   A sample can be a document, a picture, a sound, a video, an astronomical object,\n#   a row in database or CSV file,\n#   or whatever you can describe with a fixed set of quantitative traits.\n# - **n_features:**  The number of features or distinct traits that can be used to describe each\n#   item in a quantitative manner.  Features are generally real-valued, but may be Boolean or\n#   discrete-valued in some cases.\n# \n# The number of features must be fixed in advance. However it can be very high dimensional\n# (e.g. millions of features) with most of them being \"zeros\" for a given sample. This is a case\n# where `scipy.sparse` matrices can be useful, in that they are\n# much more memory-efficient than NumPy arrays.\n# \n# As we recall from the previous section (or Jupyter notebook), we represent samples (data points or instances) as rows in the data array, and we store the corresponding features, the \"dimensions,\" as columns.\n\n# ### A Simple Example: the Iris Dataset\n\n# As an example of a simple dataset, we're going to take a look at the iris data stored by scikit-learn.\n# The data consists of measurements of three different iris flower species.  There are three different species of iris\n# in this particular dataset as illustrated below:\n\n# Iris Setosa\n# <img src=\"figures/iris_setosa.jpg\" width=\"50%\">\n# \n# Iris Versicolor\n# <img src=\"figures/iris_versicolor.jpg\" width=\"50%\">\n# \n# Iris Virginica\n# <img src=\"figures/iris_virginica.jpg\" width=\"50%\">\n# \n# \n\n# ### Quick Question:\n\n# **Let's assume that we are interested in categorizing new observations; we want to predict whether unknown flowers are  Iris-Setosa, Iris-Versicolor, or Iris-Virginica flowers, respectively. Based on what we've discussed in the previous section, how would we construct such a dataset?***\n# \n# Remember: we need a 2D array of size `[n_samples x n_features]`.\n# \n# - What would the `n_samples` refer to?\n# \n# - What might the `n_features` refer to?\n# \n# Remember that there must be a **fixed** number of features for each sample, and feature\n# number *j* must be a similar kind of quantity for each sample.\n\n# ### Loading the Iris Data with Scikit-learn\n\n# For future experiments with machine learning algorithms, we recommend you to bookmark the [UCI machine learning repository](http://archive.ics.uci.edu/ml/), which hosts many of the commonly used datasets that are useful for benchmarking machine learning algorithms -- a very popular resource for machine learning practioners and researchers. Conveniently, some of these datasets are already included in scikit-learn so that we can skip the tedious parts of downloading, reading, parsing, and cleaning these text/CSV files. You can find a list of available datasets in scikit-learn at: http://scikit-learn.org/stable/datasets/#toy-datasets.\n# \n# For example, scikit-learn has a very straightforward set of data on these iris species.  The data consist of\n# the following:\n# \n# - Features in the Iris dataset:\n# \n#   1. sepal length in cm\n#   2. sepal width in cm\n#   3. petal length in cm\n#   4. petal width in cm\n# \n# - Target classes to predict:\n# \n#   1. Iris Setosa\n#   2. Iris Versicolour\n#   3. Iris Virginica\n\n# <img src=\"figures/petal_sepal.jpg\" alt=\"Sepal\" style=\"width: 50%;\"/>\n# \n# (Image: \"Petal-sepal\". Licensed under CC BY-SA 3.0 via Wikimedia Commons - https://commons.wikimedia.org/wiki/File:Petal-sepal.jpg#/media/File:Petal-sepal.jpg)\n\n# ``scikit-learn`` embeds a copy of the iris CSV file along with a helper function to load it into numpy arrays:\n\n# In[1]:\n\n\nfrom sklearn.datasets import load_iris\niris = load_iris()\n\n\n# The resulting dataset is a ``Bunch`` object: you can see what's available using\n# the method ``keys()``:\n\n# In[2]:\n\n\niris.keys()\n\n\n# The features of each sample flower are stored in the ``data`` attribute of the dataset:\n\n# In[3]:\n\n\nn_samples, n_features = iris.data.shape\nprint('Number of samples:', n_samples)\nprint('Number of features:', n_features)\n# the sepal length, sepal width, petal length and petal width of the first sample (first flower)\nprint(iris.data[0])\n\n\n# The information about the class of each sample is stored in the ``target`` attribute of the dataset:\n\n# In[ ]:\n\n\nprint(iris.data.shape)\nprint(iris.target.shape)\n\n\n# In[ ]:\n\n\nprint(iris.target)\n\n\n# In[ ]:\n\n\nimport numpy as np\n\nnp.bincount(iris.target)\n\n\n# Using the NumPy's bincount function (above), we can see that the classes are distributed uniformly in this dataset - there are 50 flowers from each species, where\n# \n# - class 0: Iris-Setosa\n# - class 1: Iris-Versicolor\n# - class 2: Iris-Virginica\n\n# These class names are stored in the last attribute, namely ``target_names``:\n\n# In[ ]:\n\n\nprint(iris.target_names)\n\n\n# This data is four dimensional, but we can visualize one or two of the dimensions\n# at a time using a simple histogram or scatter-plot.  Again, we'll start by enabling\n# matplotlib inline mode:\n\n# In[ ]:\n\n\nget_ipython().magic(u'matplotlib inline')\nimport matplotlib.pyplot as plt\n\n\n# In[ ]:\n\n\nx_index = 3\ncolors = ['blue', 'red', 'green']\n\nfor label, color in zip(range(len(iris.target_names)), colors):\n    plt.hist(iris.data[iris.target==label, x_index], \n             label=iris.target_names[label],\n             color=color)\n\nplt.xlabel(iris.feature_names[x_index])\nplt.legend(loc='upper right')\nplt.show()\n\n\n# In[ ]:\n\n\nx_index = 3\ny_index = 0\n\ncolors = ['blue', 'red', 'green']\n\nfor label, color in zip(range(len(iris.target_names)), colors):\n    plt.scatter(iris.data[iris.target==label, x_index], \n                iris.data[iris.target==label, y_index],\n                label=iris.target_names[label],\n                c=color)\n\nplt.xlabel(iris.feature_names[x_index])\nplt.ylabel(iris.feature_names[y_index])\nplt.legend(loc='upper left')\nplt.show()\n\n\n# ### Quick Exercise:\n\n# **Change** `x_index` **and** `y_index` **in the above script\n# and find a combination of two parameters\n# which maximally separate the three classes.**\n# \n# This exercise is a preview of **dimensionality reduction**, which we'll see later.\n\n# ## Other Available Data\n\n# [Scikit-learn makes available a host of datasets for testing learning algorithms](http://scikit-learn.org/stable/datasets/#dataset-loading-utilities).\n# They come in three flavors:\n# \n# - **Packaged Data:** these small datasets are packaged with the scikit-learn installation,\n#   and can be downloaded using the tools in ``sklearn.datasets.load_*``\n# - **Downloadable Data:** these larger datasets are available for download, and scikit-learn\n#   includes tools which streamline this process.  These tools can be found in\n#   ``sklearn.datasets.fetch_*``\n# - **Generated Data:** there are several datasets which are generated from models based on a\n#   random seed.  These are available in the ``sklearn.datasets.make_*``\n# \n# You can explore the available dataset loaders, fetchers, and generators using IPython's\n# tab-completion functionality.  After importing the ``datasets`` submodule from ``sklearn``,\n# type\n# \n#     datasets.load_<TAB>\n# \n# or\n# \n#     datasets.fetch_<TAB>\n# \n# or\n# \n#     datasets.make_<TAB>\n# \n# to see a list of available functions.\n\n# In[ ]:\n\n\nfrom sklearn import datasets\n\n\n# The data downloaded using the ``fetch_`` scripts are stored locally,\n# within a subdirectory of your home directory.\n# You can use the following to determine where it is:\n\n# In[ ]:\n\n\nfrom sklearn.datasets import get_data_home\nget_data_home()\n\n\n# Be warned: many of these datasets are quite large, and can take a long time to download!\n# (especially on Conference wifi).\n# \n# If you start a download within the IPython notebook\n# and you want to kill it, you can use ipython's \"kernel interrupt\" feature, available in the menu or using\n# the shortcut ``Ctrl-m i``.\n# \n# You can press ``Ctrl-m h`` for a list of all ``ipython`` keyboard shortcuts.\n\n# ## Loading Digits Data\n\n# Now we'll take a look at another dataset, one where we have to put a bit\n# more thought into how to represent the data.  We can explore the data in\n# a similar manner as above:\n\n# In[ ]:\n\n\nfrom sklearn.datasets import load_digits\ndigits = load_digits()\n\n\n# In[ ]:\n\n\ndigits.keys()\n\n\n# In[ ]:\n\n\nn_samples, n_features = digits.data.shape\nprint((n_samples, n_features))\n\n\n# In[ ]:\n\n\nprint(digits.data[0])\nprint(digits.target)\n\n\n# The target here is just the digit represented by the data.  The data is an array of\n# length 64... but what does this data mean?\n\n# There's a clue in the fact that we have two versions of the data array:\n# ``data`` and ``images``.  Let's take a look at them:\n\n# In[ ]:\n\n\nprint(digits.data.shape)\nprint(digits.images.shape)\n\n\n# We can see that they're related by a simple reshaping:\n\n# In[ ]:\n\n\nimport numpy as np\nprint(np.all(digits.images.reshape((1797, 64)) == digits.data))\n\n\n# Let's visualize the data.  It's little bit more involved than the simple scatter-plot\n# we used above, but we can do it rather quickly.\n\n# In[ ]:\n\n\n# set up the figure\nfig = plt.figure(figsize=(6, 6))  # figure size in inches\nfig.subplots_adjust(left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)\n\n# plot the digits: each image is 8x8 pixels\nfor i in range(64):\n    ax = fig.add_subplot(8, 8, i + 1, xticks=[], yticks=[])\n    ax.imshow(digits.images[i], cmap=plt.cm.binary, interpolation='nearest')\n    \n    # label the image with the target value\n    ax.text(0, 7, str(digits.target[i]))\n\n\n# We see now what the features mean.  Each feature is a real-valued quantity representing the\n# darkness of a pixel in an 8x8 image of a hand-written digit.\n# \n# Even though each sample has data that is inherently two-dimensional, the data matrix flattens\n# this 2D data into a **single vector**, which can be contained in one **row** of the data matrix.\n\n# ## Generated Data: the S-Curve\n\n# One dataset often used as an example of a simple nonlinear dataset is the S-cure:\n\n# In[ ]:\n\n\nfrom sklearn.datasets import make_s_curve\ndata, colors = make_s_curve(n_samples=1000)\nprint(data.shape)\nprint(colors.shape)\n\n\n# In[ ]:\n\n\nfrom mpl_toolkits.mplot3d import Axes3D\nax = plt.axes(projection='3d')\nax.scatter(data[:, 0], data[:, 1], data[:, 2], c=colors)\nax.view_init(10, -60)\n\n\n# This example is typically used with an unsupervised learning method called Locally\n# Linear Embedding.  We'll explore unsupervised learning in detail later in the tutorial.\n\n# ## Exercise: working with the faces dataset\n\n# Here we'll take a moment for you to explore the datasets yourself.\n# Later on we'll be using the Olivetti faces dataset.\n# Take a moment to fetch the data (about 1.4MB), and visualize the faces.\n# You can copy the code used to visualize the digits above, and modify it for this data.\n\n# In[ ]:\n\n\nfrom sklearn.datasets import fetch_olivetti_faces\n\n\n# In[ ]:\n\n\n# fetch the faces data\n\n\n# In[ ]:\n\n\n# Use a script like above to plot the faces image data.\n# hint: plt.cm.bone is a good colormap for this data\n\n\n# ### Solution:\n\n# In[ ]:\n\n\n# %load solutions/03A_faces_plot.py\n\n", "meta": {"hexsha": "54c2eb1d22c7e5e876317658c80ad31430a33c6d", "size": 12099, "ext": "py", "lang": "Python", "max_stars_repo_path": "Scipy/03 Data Representation for Machine Learning.py", "max_stars_repo_name": "erkundanec/BasicPython", "max_stars_repo_head_hexsha": "0d3bd1ccb603b94fc3701783dfb06f831ceb2541", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-02-06T18:12:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-11T07:57:19.000Z", "max_issues_repo_path": "Scipy/03 Data Representation for Machine Learning.py", "max_issues_repo_name": "erkundanec/BasicPython", "max_issues_repo_head_hexsha": "0d3bd1ccb603b94fc3701783dfb06f831ceb2541", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Scipy/03 Data Representation for Machine Learning.py", "max_forks_repo_name": "erkundanec/BasicPython", "max_forks_repo_head_hexsha": "0d3bd1ccb603b94fc3701783dfb06f831ceb2541", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-11T07:52:34.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-11T07:52:34.000Z", "avg_line_length": 29.4379562044, "max_line_length": 641, "alphanum_fraction": 0.7203074634, "include": true, "reason": "import numpy", "num_tokens": 3072, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.42250464935739196, "lm_q2_score": 0.17328819739040088, "lm_q1q2_score": 0.07321506907620585}}
{"text": "# %%markdown\n# # Introduction\n#\n# Numpy is great for exploratory data analysis because it encourages the analyst to calculate one operation at a time, rather than one datum at a time. To compute an expression like\n#\n# .. math::\n#\n#     m = \\\\sqrt{(E_1 + E_2)^2 - (p_{x1} + p_{x2})^2 - (p_{y1} + p_{y2})^2 - (p_{z1} + p_{z2})^2}\n#\n# you might first compute :math:`\\\\sqrt{(p_{x1} + p_{x2})^2 + (p_{y1} + p_{y2})^2}` for all data (which is a meaningful quantity: :math:`p_T`), then compute :math:`\\\\sqrt{{p_T}^2 + (p_{z1} + p_{z2})^2}` for all data (another meaningful quantity: :math:`|p|`), then compute the whole expression as :math:`\\\\sqrt{(E_1 + E_2)^2 - |p|^2}`. Performing each step separately on all data lets you plot and cross-check distributions of partial computations, to discover surprises as early as possible.\n#\n# This order of data processing is called \"columnar\" in the sense that a dataset may be visualized as a table in which rows are repeated measurements and columns are the different measurable quantities (same layout as `Pandas DataFrames <https://pandas.pydata.org>`__). It is also called \"vectorized\" in that a Single (virtual) Instruction is applied to Multiple Data (virtual SIMD). Numpy can be hundreds to thousands of times faster than pure Python because it avoids the overhead of handling Python instructions in the loop over numbers. Most data processing languages (R, MATLAB, IDL, all the way back to APL) work this way: an interactive interpreter controlling fast, array-at-a-time math.\n#\n# However, it's difficult to apply this methodology to non-rectangular data. If your dataset has nested structure, a different number of values per row, different data types in the same column, or cross-references or even circular references, Numpy can't help you.\n#\n# If you try to make an array with non-trivial types:\n\n# %%\nimport numpy\nnested = numpy.array([{\"x\": 1, \"y\": 1.1}, {\"x\": 2, \"y\": 2.2}, {\"x\": 3, \"y\": 3.3}, {\"x\": 4, \"y\": 4.4}, {\"x\": 5, \"y\": 5.5}])\nnested\n# array([{'x': 1, 'y': 1.1}, {'x': 2, 'y': 2.2}, {'x': 3, 'y': 3.3},\n#        {'x': 4, 'y': 4.4}, {'x': 5, 'y': 5.5}], dtype=object)\n\n# %%markdown\n# Numpy gives up and returns a ``dtype=object`` array, which means Python objects and pure Python processing. You don't get the columnar operations or the performance boost.\n#\n# For instance, you might want to say\n\n# %%\ntry:\n    nested + 100\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'TypeError'> unsupported operand type(s) for +: 'dict' and 'int'\n\n# %%markdown\n# but there is no vectorized addition for an array of dicts because there is no addition for dicts defined in pure Python. Numpy is not using its vectorized routines—it's calling Python code on each element.\n#\n# The same applies to variable-length data, such as lists of lists, where the inner lists have different lengths. This is a more serious shortcoming than the above because the list of dicts (Python's equivalent of an \"`array of structs <https://en.wikipedia.org/wiki/AOS_and_SOA>`__`\") could be manually reorganized into two numerical arrays, ``\"x\"`` and ``\"y\"`` (a \"`struct of arrays <https://en.wikipedia.org/wiki/AOS_and_SOA>`__\"). Not so with a list of variable-length lists.\n\n# %%\nvarlen = numpy.array([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6], [7.7, 8.8, 9.9]])\nvarlen\n# array([list([1.1, 2.2, 3.3]), list([]), list([4.4, 5.5]), list([6.6]),\n#        list([7.7, 8.8, 9.9])], dtype=object)\n\n# %%markdown\n# As before, we get a ``dtype=object`` without vectorized methods.\n\n# %%\ntry:\n    varlen + 100\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'TypeError'> can only concatenate list (not \"int\") to list\n\n# %%markdown\n# What's worse, this array looks purely numerical and could have been made by a process that was *supposed* to create equal-length inner lists.\n#\n# Awkward-array provides a way of talking about these data structures as arrays.\n\n# %%\nimport awkward\nnested = awkward.fromiter([{\"x\": 1, \"y\": 1.1}, {\"x\": 2, \"y\": 2.2}, {\"x\": 3, \"y\": 3.3}, {\"x\": 4, \"y\": 4.4}, {\"x\": 5, \"y\": 5.5}])\nnested\n# <Table [<Row 0> <Row 1> <Row 2> <Row 3> <Row 4>] at 0x7f25e80a01d0>\n\n# %%markdown\n# This ``Table`` is a columnar data structure with the same meaning as the Python data we built it with. To undo ``awkward.fromiter``, call ``.tolist()``.\n\n# %%\nnested.tolist()\n# [{'x': 1, 'y': 1.1},\n#  {'x': 2, 'y': 2.2},\n#  {'x': 3, 'y': 3.3},\n#  {'x': 4, 'y': 4.4},\n#  {'x': 5, 'y': 5.5}]\n\n# %%markdown\n# Values at the same position of the tree structure are contiguous in memory: this is a struct of arrays.\n\n# %%\nnested.contents[\"x\"]\n# array([1, 2, 3, 4, 5])\n\n# %%\nnested.contents[\"y\"]\n# array([1.1, 2.2, 3.3, 4.4, 5.5])\n\n# %%markdown\n# Having a structure like this means that we can perform vectorized operations on the whole structure with relatively few Python instructions (number of Python instructions scales with the complexity of the data type, not with the number of values in the dataset).\n\n# %%\n(nested + 100).tolist()\n# [{'x': 101, 'y': 101.1},\n#  {'x': 102, 'y': 102.2},\n#  {'x': 103, 'y': 103.3},\n#  {'x': 104, 'y': 104.4},\n#  {'x': 105, 'y': 105.5}]\n\n# %%\n(nested + numpy.arange(100, 600, 100)).tolist()\n# [{'x': 101, 'y': 101.1},\n#  {'x': 202, 'y': 202.2},\n#  {'x': 303, 'y': 303.3},\n#  {'x': 404, 'y': 404.4},\n#  {'x': 505, 'y': 505.5}]\n\n# %%markdown\n# It's less obvious that variable-length data can be represented in a columnar format, but it can.\n\n# %%\nvarlen = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6], [7.7, 8.8, 9.9]])\nvarlen\n# <JaggedArray [[1.1 2.2 3.3] [] [4.4 5.5] [6.6] [7.7 8.8 9.9]] at 0x7f25bc7b1438>\n\n# %%markdown\n# Unlike Numpy's ``dtype=object`` array, the inner lists are *not* Python lists and the numerical values *are* contiguous in memory. This is made possible by representing the structure (where each inner list starts and stops) in one array and the values in another.\n\n# %%\nvarlen.counts, varlen.content\n# (array([3, 0, 2, 1, 3]), array([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]))\n\n# %%markdown\n# (For fast random access, the more basic representation is ``varlen.offsets``, which is in turn a special case of a ``varlen.starts, varlen.stops`` pair. These details are discussed below.)\n#\n# A structure like this can be broadcast like Numpy with a small number of Python instructions (scales with the complexity of the data type, not the number of values).\n\n# %%\nvarlen + 100\n# <JaggedArray [[101.1 102.2 103.3] [] [104.4 105.5] [106.6] [107.7 108.8 109.9]] at 0x7f25bc7b1400>\n\n# %%\nvarlen + numpy.arange(100, 600, 100)\n# <JaggedArray [[101.1 102.2 103.3] [] [304.4 305.5] [406.6] [507.7 508.8 509.9]] at 0x7f25bc7b1da0>\n\n# %%markdown\n# You can even slice this object as though it were multidimensional (each element is a tensor of the same rank, but with different numbers of dimensions).\n\n# %%\n# Skip the first two inner lists; skip the last value in each inner list that remains.\nvarlen[2:, :-1]\n# <JaggedArray [[4.4] [] [7.7 8.8]] at 0x7f25bc755588>\n\n# %%markdown\n# The data are not rectangular, so some inner lists might have as many elements as your selection. Don't worry—you'll get error messages.\n\n# %%\ntry:\n    varlen[:, 1]\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'IndexError'> index 1 is out of bounds for jagged min size 0\n\n# %%markdown\n# Masking with the ``.counts`` is handy because all the Numpy advanced indexing rules apply (in an extended sense) to jagged arrays.\n\n# %%\nvarlen[varlen.counts > 1, 1]\n# array([2.2, 5.5, 8.8])\n\n# %%markdown\n# I've only presented the two most important awkward classes, ``Table`` and ``JaggedArray`` (and not how they combine). Each class is presented in more detail below. For now, I'd just like to point out that you can make crazy complicated data structures\n\n# %%\ncrazy = awkward.fromiter([[1.21, 4.84, None, 10.89, None],\n                          [19.36, [30.25]],\n                          [{\"x\": 36, \"y\": {\"z\": 49}}, None, {\"x\": 64, \"y\": {\"z\": 81}}]\n                         ])\n\n# %%markdown\n# and they vectorize and slice as expected.\n\n# %%\nnumpy.sqrt(crazy).tolist()\n# [[1.1, 2.2, None, 3.3000000000000003, None],\n#  [4.4, [5.5]],\n#  [{'x': 6.0, 'y': {'z': 7.0}}, None, {'x': 8.0, 'y': {'z': 9.0}}]]\n\n# %%markdown\n# This is because any awkward array can be the content of any other awkward array. Like Numpy, the features of awkward-array are simple, yet compose nicely to let you build what you need.\n\n# %%markdown\n# # Overview with sample datasets\n#\n# Many of the examples in this tutorial use ``awkward.fromiter`` to make awkward arrays from lists and ``array.tolist()`` to turn them back into lists (or dicts for ``Table``, tuples for ``Table`` with anonymous fields, Python objects for ``ObjectArrays``, etc.). These should be considered slow methods, since Python instructions are executed in the loop, but that's a necessary part of examining or building Python objects.\n#\n# Ideally, you'd want to get your data from a binary, columnar source and produce binary, columnar output, or convert only once and reuse the converted data. `Parquet <https://parquet.apache.org>`__ is a popular columnar format for storing data on disk and `Arrow <https://arrow.apache.org>`__ is a popular columnar format for sharing data in memory (between functions or applications). `ROOT <https://root.cern>`__ is a popular columnar format for particle physicists, and `uproot <https://github.com/scikit-hep/uproot>`__ natively produces awkward arrays from ROOT files.\n#\n# `HDF5 <https://www.hdfgroup.org>`__ and its Python library `h5py <https://www.h5py.org/>`__ are columnar, but only for rectangular arrays, unlike the others mentioned here. Awkward-array can *wrap* HDF5 with an interpretation layer to store columnar data structures, but then the awkward-array library wuold be needed to read the data back in a meaningful way. Awkward also has a native file format, ``.awkd`` files, which are simply ZIP archives of columns as binary blobs and metadata (just as Numpy's ``.npz`` is a ZIP of arrays with metadata). The HDF5, awkd, and pickle serialization procedures use the same protocol, which has backward and forward compatibility features.\n\n# %%markdown\n# ## NASA exoplanets from a Parquet file\n#\n# Let's start by opening a Parquet file. Awkward reads Parquet through the `pyarrow <https://arrow.apache.org/docs/python>`__ module, which is an optional dependency, so be sure you have it installed before trying the next line.\n\n# %%\nstars = awkward.fromparquet(\"tests/samples/exoplanets.parquet\")\nstars\n# <ChunkedArray [<Row 0> <Row 1> <Row 2> ... <Row 2932> <Row 2933> <Row 2934>] at 0x7f25b9c67780>\n\n# %%markdown\n# (There is also an ``awkward.toparquet`` that takes the file name and array as arguments.)\n#\n# Columns are accessible with square brackets and strings\n\n# %%\nstars[\"name\"]\n# <ChunkedArray ['11 Com' '11 UMi' '14 And' ... 'tau Gem' 'ups And' 'xi Aql'] at 0x7f25b9c67dd8>\n\n# %%markdown\n# or by dot-attribute (if the name doesn't have weird characters and doesn't conflict with a method or property name).\n\n# %%\nstars.ra, stars.dec\n# (<ChunkedArray [185.179276 229.27453599999998 352.822571 ... 107.78488200000001 24.199345 298.56201200000004] at 0x7f25b94ccf28>,\n#  <ChunkedArray [17.792868 71.823898 39.236198 ... 30.245163 41.40546 8.461452] at 0x7f25b94cca90>)\n\n# %%markdown\n# This file contains data about extrasolar planets and their host stars. As such, it's a ``Table`` full of Numpy arrays and ``JaggedArrays``. The star attributes (`\"name\"`, `\"ra\"` or right ascension in degrees, `\"dec\"` or declination in degrees, `\"dist\"` or distance in parsecs, `\"mass\"` in multiples of the sun's mass, and `\"radius\"` in multiples of the sun's radius) are plain Numpy arrays and the planet attributes (`\"name\"`, `\"orbit\"` or orbital distance in AU, `\"eccen\"` or eccentricity, `\"period\"` or periodicity in days, `\"mass\"` in multiples of Jupyter's mass, and `\"radius\"` in multiples of Jupiter's radius) are jagged because each star may have a different number of planets.\n\n# %%\nstars.planet_name\n# <ChunkedArray [['b'] ['b'] ['b'] ... ['b'] ['b' 'c' 'd'] ['b']] at 0x7f25b94dc550>\n\n# %%\nstars.planet_period, stars.planet_orbit\n# (<ChunkedArray [[326.03] [516.21997] [185.84] ... [305.5] [4.617033 241.258 1276.46] [136.75]] at 0x7f25b94cccc0>,\n#  <ChunkedArray [[1.29] [1.53] [0.83] ... [1.17] [0.059222000000000004 0.827774 2.51329] [0.68]] at 0x7f25b94cc978>)\n\n# %%markdown\n# For large arrays, only the first and last values are printed: the second-to-last star has three planets; all the other stars shown here have one planet.\n#\n# These arrays are called ``ChunkedArrays`` because the Parquet file is lazily read in chunks (Parquet's row group structure). The ``ChunkedArray`` (subdivides the file) contains ``VirtualArrays`` (read one chunk on demand), which generate the ``JaggedArrays``. This is an illustration of how each awkward class provides one feature, and you get desired behavior by combining them.\n#\n# The ``ChunkedArrays`` and ``VirtualArrays`` support the same Numpy-like access as ``JaggedArray``, so we can compute with them just as we would any other array.\n\n# %%\n# distance in parsecs → distance in light years\nstars.dist * 3.26156\n# <ChunkedArray [304.5318572 410.0433232 246.5413204 ... 367.38211839999997 43.7375196 183.5279812] at 0x7f25b94cce80>\n\n# %%\n# for all stars, drop the first planet\nstars.planet_mass[:, 1:]\n# <ChunkedArray [[] [] [] ... [] [1.981 4.132] []] at 0x7f25b94ccf60>\n\n# %%markdown\n# ## NASA exoplanets from an Arrow buffer\n#\n# The pyarrow implementation of Arrow is more complete than its implementation of Parquet, so we can use more features in the Arrow format, such as nested tables.\n#\n# Unlike Parquet, which is intended as a file format, Arrow is a memory format. You might get an Arrow buffer as the output of another function, through interprocess communication, from a network RPC call, a message bus, etc. Arrow can be saved as files, though this isn't common. In this case, we'll get it from a file.\n\n# %%\nimport pyarrow\narrow_buffer = pyarrow.ipc.open_file(open(\"tests/samples/exoplanets.arrow\", \"rb\")).get_batch(0)\nstars = awkward.fromarrow(arrow_buffer)\nstars\n# <Table [<Row 0> <Row 1> <Row 2> ... <Row 2932> <Row 2933> <Row 2934>] at 0x7f25b94f2518>\n\n# %%markdown\n# (There is also an ``awkward.toarrow`` that takes an awkward array as its only argument, returning the relevant Arrow structure.)\n#\n# This file is structured differently. Instead of jagged arrays of numbers like ``\"planet_mass\"``, ``\"planet_period\"``, and ``\"planet_orbit\"``, this file has a jagged table of ``\"planets\"``. A jagged table is a ``JaggedArray`` of ``Table``.\n\n# %%\nstars[\"planets\"]\n# <JaggedArray [[<Row 0>] [<Row 1>] [<Row 2>] ... [<Row 3928>] [<Row 3929> <Row 3930> <Row 3931>] [<Row 3932>]] at 0x7f25b94fb080>\n\n# %%markdown\n# Notice that the square brackets are nested, but the contents are ``<Row>`` objects. The second-to-last star has three planets, as before.\n#\n# We can find the non-jagged ``Table`` in the ``JaggedArray.content``.\n\n# %%\nstars[\"planets\"].content\n# <Table [<Row 0> <Row 1> <Row 2> ... <Row 3930> <Row 3931> <Row 3932>] at 0x7f25b94f2d68>\n\n# %%markdown\n# When viewed as Python lists and dicts, the ``'planets'`` field is a list of planet dicts, each with its own fields.\n\n# %%\nstars[:2].tolist()\n# [{'dec': 17.792868,\n#   'dist': 93.37,\n#   'mass': 2.7,\n#   'name': '11 Com',\n#   'planets': [{'eccen': 0.231,\n#     'mass': 19.4,\n#     'name': 'b',\n#     'orbit': 1.29,\n#     'period': 326.03,\n#     'radius': nan}],\n#   'ra': 185.179276,\n#   'radius': 19.0},\n#  {'dec': 71.823898,\n#   'dist': 125.72,\n#   'mass': 2.78,\n#   'name': '11 UMi',\n#   'planets': [{'eccen': 0.08,\n#     'mass': 14.74,\n#     'name': 'b',\n#     'orbit': 1.53,\n#     'period': 516.21997,\n#     'radius': nan}],\n#   'ra': 229.27453599999998,\n#   'radius': 29.79}]\n\n# %%markdown\n# Despite being packaged in an arguably more intuitive way, we can still get jagged arrays of numbers by requesting ``\"planets\"`` and a planet attribute (two column selections) without specifying which star or which parent.\n\n# %%\nstars.planets.name\n# <JaggedArray [['b'] ['b'] ['b'] ... ['b'] ['b' 'c' 'd'] ['b']] at 0x7f25b94dc780>\n\n# %%\nstars.planets.mass\n# <JaggedArray [[19.4] [14.74] [4.8] ... [20.6] [0.6876 1.981 4.132] [2.8]] at 0x7f25b94fb240>\n\n# %%markdown\n# Even though the ``Table`` is hidden inside the ``JaggedArray``, its ``columns`` pass through to the top.\n\n# %%\nstars.columns\n# ['dec', 'dist', 'mass', 'name', 'planets', 'ra', 'radius']\n\n# %%\nstars.planets.columns\n# ['eccen', 'mass', 'name', 'orbit', 'period', 'radius']\n\n# %%markdown\n# For a more global view of the structures contained within one of these arrays, print out its high-level type. (\"High-level\" because it presents logical distinctions, like jaggedness and tables, but not physical distinctions, like chunking and virtualness.)\n\n# %%\nprint(stars.type)\n# [0, 2935) -> 'dec'     -> float64\n#              'dist'    -> float64\n#              'mass'    -> float64\n#              'name'    -> <class 'str'>\n#              'planets' -> [0, inf) -> 'eccen'  -> float64\n#                                       'mass'   -> float64\n#                                       'name'   -> <class 'str'>\n#                                       'orbit'  -> float64\n#                                       'period' -> float64\n#                                       'radius' -> float64\n#              'ra'      -> float64\n#              'radius'  -> float64\n\n# %%markdown\n# The above should be read like a function's data type: ``argument type -> return type`` for the function that takes an index in square brackets and returns something else. For example, the first ``[0, 2935)`` means that you could put any non-negative integer less than ``2935`` in square brackets after ``stars``, like this:\n\n# %%\nstars[1734]\n# <Row 1734>\n\n# %%markdown\n# and get an object that would take ``'dec'``, ``'dist'``, ``'mass'``, ``'name'``, ``'planets'``, ``'ra'``, or ``'radius'`` in its square brackets. The return type depends on which of those strings you provide.\n\n# %%\nstars[1734][\"mass\"]   # type is float64\n# 0.54\n\n# %%\nstars[1734][\"name\"]   # type is <class 'str'>\n# 'Kepler-186'\n\n# %%\nstars[1734][\"planets\"]\n# <Table [<Row 2192> <Row 2193> <Row 2194> <Row 2195> <Row 2196>] at 0x7f25b94dc438>\n\n# %%markdown\n# The planets have their own table structure:\n\n# %%\nprint(stars[1734][\"planets\"].type)\n# [0, 5) -> 'eccen'  -> float64\n#           'mass'   -> float64\n#           'name'   -> <class 'str'>\n#           'orbit'  -> float64\n#           'period' -> float64\n#           'radius' -> float64\n\n# %%markdown\n# Notice that within the context of ``stars``, the ``planets`` could take any non-negative integer ``[0, inf)``, but for a particular star, the allowed domain is known with more precision: ``[0, 5)``. This is because ``stars[\"planets\"]`` is a jagged array—a different number of planets for each star—but one ``stars[1734][\"planets\"]`` is a simple array—five planets for *this* star.\n#\n# Passing a non-negative integer less than 5 to this array, we get an object that takes one of six strings: : ``'eccen'``, ``'mass'``, ``'name'``, ``'orbit'``, ``'period'``, and ``'radius'``.\n\n# %%\nstars[1734][\"planets\"][4]\n# <Row 2196>\n\n# %%markdown\n# and the return type of these depends on which string you provide.\n\n# %%\nstars[1734][\"planets\"][4][\"period\"]   # type is float\n# 129.9441\n\n# %%\nstars[1734][\"planets\"][4][\"name\"]   # type is <class 'str'>\n# 'f'\n\n# %%\nstars[1734][\"planets\"][4].tolist()\n# {'eccen': 0.04,\n#  'mass': nan,\n#  'name': 'f',\n#  'orbit': 0.432,\n#  'period': 129.9441,\n#  'radius': 0.10400000000000001}\n\n# %%markdown\n# (Incidentally, this is a `potentially habitable exoplanet <https://www.nasa.gov/ames/kepler/kepler-186f-the-first-earth-size-planet-in-the-habitable-zone>`__`, the first ever discovered.)\n\n# %%\nstars[1734][\"name\"], stars[1734][\"planets\"][4][\"name\"]\n# ('Kepler-186', 'f')\n\n# %%markdown\n# Some of these arguments \"commute\" and others don't. Dimensional axes have a particular order, so you can't request a planet by its row number before selecting a star, but you can swap a column-selection (string) and a row-selection (integer). For a rectangular table, it's easy to see how you can slice column-first or row-first, but it even works when the table is jagged.\n\n# %%\nstars[\"planets\"][\"name\"][1734][4]\n# 'f'\n\n# %%\nstars[1734][\"planets\"][4][\"name\"]\n# 'f'\n\n# %%markdown\n# None of these intermediate slices actually process data, so you can slice in any order that is logically correct without worrying about performance. Projections, even multi-column projections\n\n# %%\norbits = stars[\"planets\"][[\"name\", \"eccen\", \"orbit\", \"period\"]]\norbits[1734].tolist()\nIn this representation, each star's attributes must be duplicated for all of its planets, and it is not possible to show stars that have no planets (not present in this dataset), but the information is preserved in a way that Pandas can recognize and operate on. (For instance, .unstack() would widen each planet attribute into a separate column per planet and simplify the index to strictly one row per star.)\n\nThe limitation is that only a single jagged structure can be represented by a DataFrame. The structure can be arbitrarily deep in Tables (which add depth to the column names),\n\n\n# %%\narray = awkward.fromiter([{\"a\": {\"b\": 1, \"c\": {\"d\": [2]}}, \"e\": 3},\n\n# %%\nstars[1734][\"planets\"][4][\"name\"]\n# 'f'\n\n# %%markdown\n# None of these intermediate slices actually process data, so you can slice in any order that is logically correct without worrying about performance. Projections,\neven multi-column projections\n\n# %%\norbits = stars[\"planets\"][[\"name\", \"eccen\", \"orbit\", \"period\"]]\norbits[1734].tolist()\n# [{'name': 'b', 'eccen': nan, 'orbit': 0.0343, 'period': 3.8867907},\n#  {'name': 'c', 'eccen': nan, 'orbit': 0.0451, 'period': 7.267302},\n#  {'name': 'd', 'eccen': nan, 'orbit': 0.0781, 'period': 13.342996},\n#  {'name': 'e', 'eccen': nan, 'orbit': 0.11, 'period': 22.407704},\n#  {'name': 'f', 'eccen': 0.04, 'orbit': 0.432, 'period': 129.9441}]\n\n# %%markdown\n# are a useful way to restructure data without incurring a runtime cost.\n\n# %%markdown\n# ## Relationship to Pandas\n#\n# Arguably, this kind of dataset could be manipulated as a `Pandas DataFrame <https://pandas.pydata.org>`__ instead of awkward arrays. Despite the variable number of planets per star, the exoplanets dataset could be flattened into a rectangular DataFrame, in which the distinction between solar systems is represented by a two-component index (leftmost pair of columns below), a `MultiIndex <https://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html>`__.\n\n# %%\nawkward.topandas(stars, flatten=True)[-9:]\n\nif False:\n      [\"<table border=\\\"1\\\" class=\\\"dataframe\\\">\\n\",\n       \"  <thead>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>dec</th>\\n\",\n       \"      <th>dist</th>\\n\",\n       \"      <th>mass</th>\\n\",\n       \"      <th>name</th>\\n\",\n       \"      <th colspan=\\\"6\\\" halign=\\\"left\\\">planets</th>\\n\",\n       \"      <th>ra</th>\\n\",\n       \"      <th>radius</th>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>eccen</th>\\n\",\n       \"      <th>mass</th>\\n\",\n       \"      <th>name</th>\\n\",\n       \"      <th>orbit</th>\\n\",\n       \"      <th>period</th>\\n\",\n       \"      <th>radius</th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"    </tr>\\n\",\n       \"  </thead>\\n\",\n       \"  <tbody>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"4\\\" valign=\\\"top\\\">2931</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>-15.937480</td>\\n\",\n       \"      <td>3.60</td>\\n\",\n       \"      <td>0.78</td>\\n\",\n       \"      <td>49</td>\\n\",\n       \"      <td>0.1800</td>\\n\",\n       \"      <td>0.01237</td>\\n\",\n       \"      <td>101</td>\\n\",\n       \"      <td>0.538000</td>\\n\",\n       \"      <td>162.870000</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>26.017012</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>-15.937480</td>\\n\",\n       \"      <td>3.60</td>\\n\",\n       \"      <td>0.78</td>\\n\",\n       \"      <td>49</td>\\n\",\n       \"      <td>0.1600</td>\\n\",\n       \"      <td>0.01237</td>\\n\",\n       \"      <td>102</td>\\n\",\n       \"      <td>1.334000</td>\\n\",\n       \"      <td>636.130000</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>26.017012</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <td>-15.937480</td>\\n\",\n       \"      <td>3.60</td>\\n\",\n       \"      <td>0.78</td>\\n\",\n       \"      <td>49</td>\\n\",\n       \"      <td>0.0600</td>\\n\",\n       \"      <td>0.00551</td>\\n\",\n       \"      <td>103</td>\\n\",\n       \"      <td>0.133000</td>\\n\",\n       \"      <td>20.000000</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>26.017012</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>3</th>\\n\",\n       \"      <td>-15.937480</td>\\n\",\n       \"      <td>3.60</td>\\n\",\n       \"      <td>0.78</td>\\n\",\n       \"      <td>49</td>\\n\",\n       \"      <td>0.2300</td>\\n\",\n       \"      <td>0.00576</td>\\n\",\n       \"      <td>104</td>\\n\",\n       \"      <td>0.243000</td>\\n\",\n       \"      <td>49.410000</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>26.017012</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2932</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>30.245163</td>\\n\",\n       \"      <td>112.64</td>\\n\",\n       \"      <td>2.30</td>\\n\",\n       \"      <td>53</td>\\n\",\n       \"      <td>0.0310</td>\\n\",\n       \"      <td>20.60000</td>\\n\",\n       \"      <td>98</td>\\n\",\n       \"      <td>1.170000</td>\\n\",\n       \"      <td>305.500000</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>107.784882</td>\\n\",\n       \"      <td>26.80</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"3\\\" valign=\\\"top\\\">2933</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>41.405460</td>\\n\",\n       \"      <td>13.41</td>\\n\",\n       \"      <td>1.30</td>\\n\",\n       \"      <td>48</td>\\n\",\n       \"      <td>0.0215</td>\\n\",\n       \"      <td>0.68760</td>\\n\",\n       \"      <td>98</td>\\n\",\n       \"      <td>0.059222</td>\\n\",\n       \"      <td>4.617033</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>24.199345</td>\\n\",\n       \"      <td>1.56</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>41.405460</td>\\n\",\n       \"      <td>13.41</td>\\n\",\n       \"      <td>1.30</td>\\n\",\n       \"      <td>48</td>\\n\",\n       \"      <td>0.2596</td>\\n\",\n       \"      <td>1.98100</td>\\n\",\n       \"      <td>99</td>\\n\",\n       \"      <td>0.827774</td>\\n\",\n       \"      <td>241.258000</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>24.199345</td>\\n\",\n       \"      <td>1.56</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <td>41.405460</td>\\n\",\n       \"      <td>13.41</td>\\n\",\n       \"      <td>1.30</td>\\n\",\n       \"      <td>48</td>\\n\",\n       \"      <td>0.2987</td>\\n\",\n       \"      <td>4.13200</td>\\n\",\n       \"      <td>100</td>\\n\",\n       \"      <td>2.513290</td>\\n\",\n       \"      <td>1276.460000</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>24.199345</td>\\n\",\n       \"      <td>1.56</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2934</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>8.461452</td>\\n\",\n       \"      <td>56.27</td>\\n\",\n       \"      <td>2.20</td>\\n\",\n       \"      <td>55</td>\\n\",\n       \"      <td>0.0000</td>\\n\",\n       \"      <td>2.80000</td>\\n\",\n       \"      <td>98</td>\\n\",\n       \"      <td>0.680000</td>\\n\",\n       \"      <td>136.750000</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>298.562012</td>\\n\",\n       \"      <td>12.00</td>\\n\",\n       \"    </tr>\\n\",\n       \"  </tbody>\\n\",\n       \"</table>\\n\"]\n\n# %%markdown\n# In this representation, each star's attributes must be duplicated for all of its planets, and it is not possible to show stars that have no planets (not present in this dataset), but the information is preserved in a way that Pandas can recognize and operate on. (For instance, ``.unstack()`` would widen each planet attribute into a separate column per planet and simplify the index to strictly one row per star.)\n#\n# The limitation is that only a single jagged structure can be represented by a DataFrame. The structure can be arbitrarily deep in ``Tables`` (which add depth to the column names),\n\n# %%\narray = awkward.fromiter([{\"a\": {\"b\": 1, \"c\": {\"d\": [2]}}, \"e\": 3},\n                          {\"a\": {\"b\": 4, \"c\": {\"d\": [5, 5.1]}}, \"e\": 6},\n                          {\"a\": {\"b\": 7, \"c\": {\"d\": [8, 8.1, 8.2]}}, \"e\": 9}])\nawkward.topandas(array, flatten=True)\n\nif False:\n      [\"<table border=\\\"1\\\" class=\\\"dataframe\\\">\\n\",\n       \"  <thead>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th colspan=\\\"2\\\" halign=\\\"left\\\">a</th>\\n\",\n       \"      <th>e</th>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>b</th>\\n\",\n       \"      <th>c</th>\\n\",\n       \"      <th></th>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>d</th>\\n\",\n       \"      <th></th>\\n\",\n       \"    </tr>\\n\",\n       \"  </thead>\\n\",\n       \"  <tbody>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>1</td>\\n\",\n       \"      <td>2.0</td>\\n\",\n       \"      <td>3</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"2\\\" valign=\\\"top\\\">1</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>4</td>\\n\",\n       \"      <td>5.0</td>\\n\",\n       \"      <td>6</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>4</td>\\n\",\n       \"      <td>5.1</td>\\n\",\n       \"      <td>6</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"3\\\" valign=\\\"top\\\">2</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>7</td>\\n\",\n       \"      <td>8.0</td>\\n\",\n       \"      <td>9</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>7</td>\\n\",\n       \"      <td>8.1</td>\\n\",\n       \"      <td>9</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <td>7</td>\\n\",\n       \"      <td>8.2</td>\\n\",\n       \"      <td>9</td>\\n\",\n       \"    </tr>\\n\",\n       \"  </tbody>\\n\",\n       \"</table>\\n\"]\n\n# %%markdown\n# and arbitrarily deep in ``JaggedArrays`` (which add depth to the row names),\n\n# %%\narray = awkward.fromiter([{\"a\": 1, \"b\": [[2.2, 3.3, 4.4], [], [5.5, 6.6]]},\n                          {\"a\": 10, \"b\": [[1.1], [2.2, 3.3], [], [4.4]]},\n                          {\"a\": 100, \"b\": [[], [9.9]]}])\nawkward.topandas(array, flatten=True)\n\nif False:\n      [\"<table border=\\\"1\\\" class=\\\"dataframe\\\">\\n\",\n       \"  <thead>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>a</th>\\n\",\n       \"      <th>b</th>\\n\",\n       \"    </tr>\\n\",\n       \"  </thead>\\n\",\n       \"  <tbody>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"5\\\" valign=\\\"top\\\">0</th>\\n\",\n       \"      <th rowspan=\\\"3\\\" valign=\\\"top\\\">0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>1</td>\\n\",\n       \"      <td>2.2</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>1</td>\\n\",\n       \"      <td>3.3</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <td>1</td>\\n\",\n       \"      <td>4.4</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"2\\\" valign=\\\"top\\\">2</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>1</td>\\n\",\n       \"      <td>5.5</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>1</td>\\n\",\n       \"      <td>6.6</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"4\\\" valign=\\\"top\\\">1</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>10</td>\\n\",\n       \"      <td>1.1</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"2\\\" valign=\\\"top\\\">1</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>10</td>\\n\",\n       \"      <td>2.2</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>10</td>\\n\",\n       \"      <td>3.3</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>3</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>10</td>\\n\",\n       \"      <td>4.4</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>100</td>\\n\",\n       \"      <td>9.9</td>\\n\",\n       \"    </tr>\\n\",\n       \"  </tbody>\\n\",\n       \"</table>\\n\"]\n\n# %%markdown\n# and they can even have two ``JaggedArrays`` at the same level if their number of elements is the same (at all levels of depth).\n\n# %%\narray = awkward.fromiter([{\"a\": [[1.1, 2.2, 3.3], [], [4.4, 5.5]], \"b\": [[1, 2, 3], [], [4, 5]]},\n                          {\"a\": [[1.1], [2.2, 3.3], [], [4.4]],    \"b\": [[1], [2, 3], [], [4]]},\n                          {\"a\": [[], [9.9]],                       \"b\": [[], [9]]}])\nawkward.topandas(array, flatten=True)\n\nif False:\n      [\"<table border=\\\"1\\\" class=\\\"dataframe\\\">\\n\",\n       \"  <thead>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>a</th>\\n\",\n       \"      <th>b</th>\\n\",\n       \"    </tr>\\n\",\n       \"  </thead>\\n\",\n       \"  <tbody>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"5\\\" valign=\\\"top\\\">0</th>\\n\",\n       \"      <th rowspan=\\\"3\\\" valign=\\\"top\\\">0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>1.1</td>\\n\",\n       \"      <td>1</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>2.2</td>\\n\",\n       \"      <td>2</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <td>3.3</td>\\n\",\n       \"      <td>3</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"2\\\" valign=\\\"top\\\">2</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>4.4</td>\\n\",\n       \"      <td>4</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>5.5</td>\\n\",\n       \"      <td>5</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"4\\\" valign=\\\"top\\\">1</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>1.1</td>\\n\",\n       \"      <td>1</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"2\\\" valign=\\\"top\\\">1</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>2.2</td>\\n\",\n       \"      <td>2</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>3.3</td>\\n\",\n       \"      <td>3</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>3</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>4.4</td>\\n\",\n       \"      <td>4</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>9.9</td>\\n\",\n       \"      <td>9</td>\\n\",\n       \"    </tr>\\n\",\n       \"  </tbody>\\n\",\n       \"</table>\\n\"]\n\n# %%markdown\n# But if there are two ``JaggedArrays`` with *different* structure at the same level, a single DataFrame cannot represent them.\n\n# %%\narray = awkward.fromiter([{\"a\": [1, 2, 3], \"b\": [1.1, 2.2]},\n                          {\"a\": [1],       \"b\": [1.1, 2.2, 3.3]},\n                          {\"a\": [1, 2],    \"b\": []}])\ntry:\n    awkward.topandas(array, flatten=True)\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'ValueError'> this array has more than one jagged array structure\n\n# %%markdown\n# To describe data like these, you'd need two DataFrames, and any calculations involving both ``\"a\"`` and ``\"b\"`` would have to include a join on those DataFrames. Awkward arrays are not limited in this way: the last ``array`` above is a valid awkward array and is useful for calculations that mix ``\"a\"`` and ``\"b\"``.\n\n# %%markdown\n# ## LHC data from a ROOT file\n#\n# Particle physicsts need structures like these—in fact, they have been a staple of particle physics analyses for decades. The `ROOT <https://root.cern>`__ file format was developed in the mid-90's to serialize arbitrary C++ data structures in a columnar way (replacing ZEBRA and similar Fortran projects that date back to the 70's). The `PyROOT <https://root.cern.ch/pyroot>`__ library dynamically wraps these objects to present them in Python, though with a performance penalty. The `uproot <https://github.com/scikit-hep/uproot>`__ library reads columnar data directly from ROOT files in Python without intermediary C++.\n\n# %%\nimport uproot\nevents = uproot.open(\"http://scikit-hep.org/uproot/examples/HZZ-objects.root\")[\"events\"].lazyarrays()\nevents\n# <Table [<Row 0> <Row 1> <Row 2> ... <Row 2418> <Row 2419> <Row 2420>] at 0x781189cd7b70>\n\n# %%\nevents.columns\n# ['jetp4',\n#  'jetbtag',\n#  'jetid',\n#  'muonp4',\n#  'muonq',\n#  'muoniso',\n#  'electronp4',\n#  'electronq',\n#  'electroniso',\n#  'photonp4',\n#  'photoniso',\n#  'MET',\n#  'MC_bquarkhadronic',\n#  'MC_bquarkleptonic',\n#  'MC_wdecayb',\n#  'MC_wdecaybbar',\n#  'MC_lepton',\n#  'MC_leptonpdgid',\n#  'MC_neutrino',\n#  'num_primaryvertex',\n#  'trigger_isomu24',\n#  'eventweight']\n\n# %%markdown\n# This is a typical particle physics dataset (though small!) in that it represents the momentum and energy (``\"p4\"`` for `Lorentz 4-momentum <https://en.wikipedia.org/wiki/Four-vector`__) of several different species of particles: ``\"jet\"``, ``\"muon\"``, ``\"electron\"``, and ``\"photon\"``. Each collision can produce a different number of particles in each species. Other variables, such as missing transverse energy or ``\"MET\"``, have one value per collision event. Events with zero particles in a species are valuable for the event-level data.\n\n# %%\n# The first event has two muons.\nevents.muonp4\n# <ChunkedArray [[TLorentzVector(-52.899, -11.655, -8.1608, 54.779) TLorentzVector(37.738, 0.69347, -11.308, 39.402)] [TLorentzVector(-0.81646, -24.404, 20.2, 31.69)] [TLorentzVector(48.988, -21.723, 11.168, 54.74) TLorentzVector(0.82757, 29.801, 36.965, 47.489)] ... [TLorentzVector(-29.757, -15.304, -52.664, 62.395)] [TLorentzVector(1.1419, 63.61, 162.18, 174.21)] [TLorentzVector(23.913, -35.665, 54.719, 69.556)]] at 0x781189cd7fd0>\n\n# %%\n# The first event has zero jets.\nevents.jetp4\n# <ChunkedArray [[] [TLorentzVector(-38.875, 19.863, -0.89494, 44.137)] [] ... [TLorentzVector(-3.7148, -37.202, 41.012, 55.951)] [TLorentzVector(-36.361, 10.174, 226.43, 229.58) TLorentzVector(-15.257, -27.175, 12.12, 33.92)] []] at 0x781189cd7be0>\n\n# %%\n# Every event has exactly one MET.\nevents.MET\n# <ChunkedArray [TVector2(5.9128, 2.5636) TVector2(24.765, -16.349) TVector2(-25.785, 16.237) ... TVector2(18.102, 50.291) TVector2(79.875, -52.351) TVector2(19.714, -3.5954)] at 0x781189cfe780>\n\n# %%markdown\n# Unlike the exoplanet data, these events cannot be represented as a DataFrame because of the different numbers of particles in each species and because zero-particle events have value. Even with just ``\"muonp4\"``, ``\"jetp4\"``, and ``\"MET\"``, there is no translation.\n\n# %%\ntry:\n    awkward.topandas(events[[\"muonp4\", \"jetp4\", \"MET\"]], flatten=True)\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'NameError'> name 'awkward' is not defined\n\n# %%markdown\n# It could be described as a collection of DataFrames, in which every operation relating particles in the same event would require a join. But that would make analysis harder, not easier. An event has meaning on its own.\n\n# %%\nevents[0].tolist()\n# {'jetp4': [],\n#  'jetbtag': [],\n#  'jetid': [],\n#  'muonp4': [TLorentzVector(-52.899, -11.655, -8.1608, 54.779),\n#   TLorentzVector(37.738, 0.69347, -11.308, 39.402)],\n#  'muonq': [1, -1],\n#  'muoniso': [4.200153350830078, 2.1510612964630127],\n#  'electronp4': [],\n#  'electronq': [],\n#  'electroniso': [],\n#  'photonp4': [],\n#  'photoniso': [],\n#  'MET': TVector2(5.9128, 2.5636),\n#  'MC_bquarkhadronic': TVector3(0, 0, 0),\n#  'MC_bquarkleptonic': TVector3(0, 0, 0),\n#  'MC_wdecayb': TVector3(0, 0, 0),\n#  'MC_wdecaybbar': TVector3(0, 0, 0),\n#  'MC_lepton': TVector3(0, 0, 0),\n#  'MC_leptonpdgid': 0,\n#  'MC_neutrino': TVector3(0, 0, 0),\n#  'num_primaryvertex': 6,\n#  'trigger_isomu24': True,\n#  'eventweight': 0.009271008893847466}\n\n# %%markdown\n# Particle physics isn't alone in this: analyzing JSON-formatted log files in production systems or allele likelihoods in genomics are two other fields where variable-length, nested structures can help. Arbitrary data structures are useful and working with them in columns provides a new way to do exploratory data analysis: one array at a time.\n\n# %%markdown\n# # Awkward-array data model\n#\n# Awkward array features are provided by a suite of classes that each extend Numpy arrays in one small way. These classes may then be composed to combine features.\n#\n# In this sense, Numpy arrays are awkward-array's most basic array class. A Numpy array is a small Python object that points to a large, contiguous region of memory, and, as much as possible, operations replace or change the small Python object, not the big data buffer. Therefore, many Numpy operations are *views*, rather than *in-place operations* or *copies*, leaving the original value intact but returning a new value that is linked to the original. Assigning to arrays and in-place operations are allowed, but they are more complicated to use because one must be aware of which arrays are views and which are copies.\n#\n# Awkward-array's model is to treat all arrays as though they were immutable, favoring views over copies, and not providing any high-level in-place operations on low-level memory buffers (i.e. no in-place assignment).\n#\n# Numpy provides complete control over the interpretation of an ``N`` dimensional array. A Numpy array has a `dtype <https://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html>`__ to interpret bytes as signed and unsigned integers of various bit-widths, floating-point numbers, booleans, little endian and big endian, fixed-width bytestrings (for applications such as 6-byte MAC addresses or human-readable strings with padding), or `record arrays <https://docs.scipy.org/doc/numpy/user/basics.rec.html>`__ for contiguous structures. A Numpy array has a `pointer <https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.ctypes.html>`__ to the first element of its data buffer (``array.ctypes.data``) and a `shape <https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.shape.html>`__ to describe its ``N`` dimensions as a rank-``N`` tensor. Only ``shape[0]`` is the length as returned by the Python function ``len``. Furthermore, an `order <https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.flags.html>`__ flag determines if rank > 1 arrays are laid out in \"C\" order or \"Fortran\" order. A Numpy array also has a `stride <https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.strides.html>`__ to determine how many bytes separate one element from the next. (Data in a Numpy array need not be strictly contiguous, but they must be regular: the number of bytes seprating them is a constant.) This stride may even be negative to describe a reversed view of an array, which allows any ``slice`` of an array, even those with ``skip != 1`` to be a view, rather than a copy. Numpy arrays also have flags to determine whether they `own <https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.flags.html>`__ their data buffer (and should therefore delete it when the Python object goes out of scope) and whether the data buffer is `writable <https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.flags.html>`__.\n\n# %%markdown\n#\n# The biggest restriction on this data model is that Numpy arrays are strictly rectangular. The ``shape`` and ``stride`` are constants, enforcing a regular layout. Awkward's ``JaggedArray`` is a generalization of Numpy's rank-2 arrays—that is, arrays of arrays—in that the inner arrays of a ``JaggedArray`` may all have different lengths. For higher ranks, such as arrays of arrays of arrays, put a ``JaggedArray`` inside another as its ``content``. An important special case of ``JaggedArray`` is ``StringArray``, whose ``content`` is interpreted as characters (with or without encoding), which represents an array of strings without unnecessary padding, as in Numpy's case.\n#\n# Although Numpy's `record arrays <https://docs.scipy.org/doc/numpy/user/basics.rec.html>`__ present a buffer as a table, with differently typed, named columns, that table must be contiguous or interleaved (with non-trivial ``strides``) in memory: an `array of structs <https://en.wikipedia.org/wiki/AOS_and_SOA>`__. Awkward's ``Table`` provides the same interface, except that each column may be anywhere in memory, stored in a ``contents`` dict mapping field names to arrays. This is a true generalization: a ``Table`` may be a wrapped view of a Numpy record array, but not vice-versa. Use a ``Table`` anywhere you'd have a record/class/struct in non-columnar data structures. A ``Table`` with anonymous (integer-valued, rather than string-valued) fields is like an array of strongly typed tuples.\n#\n# Numpy has a `masked array <https://docs.scipy.org/doc/numpy/reference/maskedarray.html>`__ module for nullable data—values that may be \"missing\" (like Python's ``None``). Naturally, the only kinds of arrays Numpy can mask are subclasses of its own ``ndarray``, and we need to be able to mask any awkward array, so the awkward library defines its own ``MaskedArray``. Additionally, we sometimes want to mask with bits, rather than bytes (e.g. for Arrow compatibility), so there's a ``BitMaskedArray``, and sometimes we want to mask large structures without using memory for the masked-out values, so there's an ``IndexedMaskedArray`` (fusing the functionality of a ``MaskedArray`` with an ``IndexedArray``).\n#\n# Numpy has no provision for an array containing different data types (\"heterogeneous\"), but awkward-array has a ``UnionArray``. The ``UnionArray`` stores data for each type as separate ``contents`` and identifies the types and positions of each element in the ``contents`` using ``tags`` and ``index`` arrays (equivalent to Arrow's `dense union type <https://arrow.apache.org/docs/memory_layout.html#dense-union-type>`__ with ``types`` and ``offsets`` buffers). As a data type, unions are a counterpart to records or tuples (making ``UnionArray`` a counterpart to ``Table``): each record/tuple contains *all* of its ``contents`` but a union contains *any* of its ``contents``. (Note that a ``UnionArray`` may be the best way to interleave two arrays, even if they have the same type. Heterogeneity is not a necessary feature of a ``UnionArray``.)\n#\n# Numpy has a ``dtype=object`` for arrays of Python objects, but awkward's ``ObjectArray`` creates Python objects on demand from array data. A large dataset of some ``Point`` class, containing floating-point members ``x`` and ``y``, can be stored as an ``ObjectArray`` of a ``Table`` of ``x`` and ``y`` with much less memory than a Numpy array of ``Point`` objects. The ``ObjectArray`` has a ``generator`` function that produces Python objects from array elements.  ``StringArray`` is also a special case of ``ObjectArray``, which instantiates variable-length character contents as Python strings.\n#\n# Although an ``ObjectArray`` can save memory, creating Python objects in a loop may still use more computation time than is necessary. Therefore, awkward arrays can also have vectorized ``Methods``—bound functions that operate on the array data, rather than instantiating every Python object in an ``ObjectArray``. Although an ``ObjectArray`` is a good use-case for ``Methods``, any awkward array can have them. (The second most common case being a ``JaggedArray`` of ``ObjectArrays``.)\n#\n# The nesting of awkward arrays within awkward arrays need not be tree-like: they can have cross-references and cyclic references (using ordinary Python assignment). ``IndexedArray`` can aid in building complex structures: it is simply an integer ``index`` that would be applied to its ``content`` with `integer array indexing <https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html#integer-array-indexing>`__ to get any element. ``IndexedArray`` is the equivalent of a pointer in non-columnar data structures.\n#\n# The counterpart of an ``IndexedArray`` is a ``SparseArray``: whereas an ``IndexedArray`` consists of pointers *to* elements of its ``content``, a ``SparseArray`` consists of pointers *from* elements of its content, representing a very large array in terms of its non-zero (or non-``default``) elements. Awkward's ``SparseArray`` is a `coordinate format (COO) <https://scipy-lectures.org/advanced/scipy_sparse/coo_matrix.html>`__, one-dimensional array.\n#\n# Another limitation of Numpy is that arrays cannot span multiple memory buffers. Awkward's ``ChunkedArray`` represents a single logical array made of physical ``chunks`` that may be anywhere in memory. A ``ChunkedArray``'s ``chunksizes`` may be known or unknown. One application of ``ChunkedArray`` is to append data to an array without allocating on every call: ``AppendableArray`` allocates memory in equal-sized chunks.\n#\n# Another application of ``ChunkedArray`` is to lazily load data in chunks. Awkward's ``VirtualArray`` calls its ``generator`` function to materialize an array when needed, and a ``ChunkedArray`` of ``VirtualArrays`` is a classic lazy-loading array, used to gradually read Parquet and ROOT files. In most libraries, lazy-loading is not a part of the data but a feature of the reading interface. Nesting virtualness makes it possible to load ``Tables`` within ``Tables``, where even the columns of the inner ``Tables`` are on-demand.\n#\n# For more details, see `array classes <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc>`__.\n#\n# * `Jaggedness <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#jaggedness>`__\n#\n#    * `JaggedArray <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#jaggedarray>`__\n#    * `Helper functions <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#helper-functions>`__\n#\n# * `Product types <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#product-types>`__\n#\n#    * `Table <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#table>`__\n#\n# * `Sum types <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#sum-types>`__\n#\n#    * `UnionArray <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#unionarray>`__\n#\n# * `Option types <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#option-types>`__\n#\n#    * `MaskedArray <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#maskedarray>`__\n#    * `BitMaskedArray <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#bitmaskedarray>`__\n#    * `IndexedMaskedArray <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#indexedmaskedarray>`__\n#\n# * `Indirection <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#indirection>`__\n#\n#    * `IndexedArray <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#indexedarray>`__\n#    * `SparseArray <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#sparsearray>`__\n#    * `Helper functions <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#helper-functions-1>`__\n#\n# * `Opaque objects <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#opaque-objects>`__\n#\n#    * `Mix-in Methods <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#mix-in-methods>`__\n#    * `ObjectArray <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#objectarray>`__\n#    * `StringArray <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#stringarray>`__\n#\n# * `Non-contiguousness <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#non-contiguousness>`__\n#\n#    * `ChunkedArray <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#chunkedarray>`__\n#    * `AppendableArray <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#appendablearray>`__\n#\n# * `Laziness <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#laziness>`__\n#\n#    * `VirtualArray <https://github.com/scikit-hep/awkward-array/blob/master/docs/classes.adoc#virtualarray>`__\n\n# %%markdown\n# ## Mutability\n#\n# Awkward arrays are considered immutable in the sense that elements of the data cannot be modified in-place. That is, assignment with square brackets at an integer index raises an error. Awkward does not prevent the underlying Numpy arrays from being modified in-place, though that can lead to confusing results—the behavior is left undefined. The reason for this omission in functionality is that the internal representation of columnar data structures is more constrained than their non-columnar counterparts: some in-place modification can't be defined, and others have surprising side-effects.\n#\n# However, the Python objects representing awkward arrays can be changed in-place. Each class has properties defining its structure, such as ``content``, and these may be replaced at any time. (Replacing properties does not change values in any Numpy arrays.) In fact, this is the only way to build cyclic references: an object in Python must be assigned to a name before that name can be used as a reference.\n#\n# Awkward arrays are appendable, but only through ``AppendableArray``, and ``Table`` columns may be added, changed, or removed. The only use of square-bracket assignment (i.e. ``__setitem__``) is to modify ``Table`` columns.\n#\n# Awkward arrays produced by an external program may grow continuously, as long as more deeply nested arrays are filled first. That is, the ``content`` of a ``JaggedArray`` must be updated before updating its structure arrays (``starts`` and ``stops``). The definitions of awkward array validity allow for nested elements with no references pointing at them (\"unreachable\" elements), but not for references pointing to a nested element that doesn't exist.\n\n# %%markdown\n# ## Relationship to Arrow\n#\n# `Apache Arrow <https://arrow.apache.org>`__ is a cross-language, columnar memory format for complex data structures. There is intentionally a high degree of overlap between awkward-array and Arrow. But whereas Arrow's focus is data portability, awkward's focus is computation: it would not be unusual to get data from Arrow, compute something with awkward-array, then return it to another Arrow buffer. For this reason, ``awkward.fromarrow`` is a zero-copy view. Awkward's data representation is broader than Arrow's, so ``awkward.toarrow`` does, in general, perform a copy.\n#\n# The main difference between awkward-array and Arrow is that awkward-array does not require all arrays to be included within a contiguous memory buffer, though libraries like `pyarrow <https://arrow.apache.org/docs/python>`__ relax this criterion while building a compliant Arrow buffer. This restriction does imply that Arrow cannot encode cross-references or cyclic dependencies.\n#\n# Arrow also doesn't have the luxury of relying on Numpy to define its `primitive arrays <https://arrow.apache.org/docs/memory_layout.html#primitive-value-arrays>`__, so it has a fixed endianness, has no regular tensors without expressing it as a jagged array, and requires 32-bit integers for indexing, instead of taking whatever integer type a user provides.\n#\n# `Nullability <https://arrow.apache.org/docs/memory_layout.html#null-bitmaps>`__ is an optional property of every data type in Arrow, but it's a structure element in awkward. Similarly, `dictionary encoding <https://arrow.apache.org/docs/memory_layout.html#dictionary-encoding>`__ is built into Arrow as a fundamental property, but it would be built from an ``IndexedArray`` in awkward. Chunking and lazy-loading are supported by readers such as `pyarrow <https://arrow.apache.org/docs/python>`__, but they're not part of the Arrow data model.\n#\n# The following list translates awkward-array classes and features to their Arrow counterparts, if possible.\n#\n# * ``JaggedArray``: Arrow's `list type <https://arrow.apache.org/docs/memory_layout.html#list-type>`__.\n# * ``Table``: Arrow's `struct type <https://arrow.apache.org/docs/memory_layout.html#struct-type>`__, though columns can be added to or removed from awkward ``Tables`` whereas Arrow is strictly immutable.\n# * ``BitMaskedArray``: every data type in Arrow potentially has a `null bitmap <https://arrow.apache.org/docs/memory_layout.html#null-bitmaps>`__, though it's an explicit array structure in awkward. (Arrow has no counterpart for Awkward's ``MaskedArray`` or ``IndexedMaskedArray``.)\n# * ``UnionArray``: directly equivalent to Arrow's `dense union <https://arrow.apache.org/docs/memory_layout.html#dense-union-type>`__. Arrow also has a `sparse union <https://arrow.apache.org/docs/memory_layout.html#sparse-union-type>`__, which awkward-array only has as a ``UnionArray.fromtags`` constructor that builds the dense union on the fly from a sparse union.\n# * ``ObjectArray`` and ``Methods``: no counterpart because Arrow must be usable in any language.\n# * ``StringArray``: \"string\" is a logical type built on top of Arrow's `list type <https://arrow.apache.org/docs/memory_layout.html#list-type>`__.\n# * ``IndexedArray``: no counterpart (though its role in building `dictionary encoding <https://arrow.apache.org/docs/memory_layout.html#dictionary-encoding>`__ is built into Arrow as a fundamental property).\n# * ``SparseArray``: no counterpart.\n# * ``ChunkedArray``: no counterpart (though a reader may deal with non-contiguous data).\n# * ``AppendableArray``: no counterpart; Arrow is strictly immutable.\n# * ``VirtualArray``: no counterpart (though a reader may lazily load data).\n\n# %%markdown\n# # High-level operations: common to all classes\n#\n# There are three levels of abstraction in awkward-array: high-level operations for data analysis, low-level operations for engineering the structure of the data, and implementation details. Implementation details are handled in the usual way for Python: if exposed at all, class, method, and function names begin with underscores and are not guaranteed to be stable from one release to the next. There is more than one implementation of awkward: the original awkward library, which depends only on Numpy, awkward-numba, which uses Numba to just-in-time compile its operations, and awkward-cpp, which has precompiled operations. Each has its own implementation details.\n#\n# The distinction between high-level operations and low-level operations is more subtle and developed as awkward-array was put to use. Data analysts care about the logical structure of the data—whether it is jagged, what the column names are, whether certain values could be ``None``, etc. Data engineers (or an analyst in \"engineering mode\") care about contiguousness, how much data are in memory at a given time, whether strings are dictionary-encoded, whether arrays have unreachable elements, etc. The dividing line is between high-level types and low-level array layout (both of which are defined in their own sections below). The following awkward classes have the same high-level type as their content:\n#\n# * ``IndexedArray`` because indirection to type ``T`` has type ``T``,\n# * ``SparseArray`` because a lookup of elements with type ``T`` has type ``T``,\n# * ``ChunkedArray`` because the chunks, which must have the same type as each other, collectively have that type when logically concatenated,\n# * ``AppendableArray`` because it's a special case of ``ChunkedArray``,\n# * ``VirtualArray`` because it produces an array of a given type on demand,\n# * ``UnionArray`` has the same type as its ``contents`` *only if* all ``contents`` have the same type as each other.\n#\n# All other classes, such as ``JaggedArray``, have a logically distinct type from their contents.\n#\n# This section describes a suite of operations that are common to all awkward classes. For some high-level types, the operation is meaningless or results in an error, such as the jagged ``counts`` of an array that is not jagged at any level, or the ``columns`` of an array that contains no tables, but the operation has a well-defined action on every array class. To use these operations, you do need to understand the high-level type of your data, but not whether it is wrapped in an ``IndexedArray``, a ``SparseArray``, a ``ChunkedArray``, an ``AppendableArray``, or a ``VirtualArray``.\n\n# %%markdown\n# ## Slicing with square brackets\n#\n# The primary operation for all classes is slicing with square brackets. This is the operation defined by Python's ``__getitem__`` method. It is so basic that high-level types are defined in terms of what they return when a scalar argument is passed in square brakets.\n#\n# Just as Numpy's slicing reproduces but generalizes Python sequence behavior, awkward-array reproduces (most of) `Numpy's slicing behavior <https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html>`__ and generalizes it in certain cases. An integer argument, a single slice argument, a single Numpy array-like of booleans or integers, and a tuple of any of the above is handled just like Numpy. Awkward-array does not handle ellipsis (because the depth of an awkward array can be different on different branches of a ``Table`` or ``UnionArray``) or ``None`` (because it's not always possible to insert a ``newaxis``). Numpy `record arrays <https://docs.scipy.org/doc/numpy/user/basics.rec.html>`__ accept a string or sequence of strings as a column argument if it is the only argument, not in a tuple with other types. Awkward-array accepts a string or sequence of strings if it contains a ``Table`` at some level.\n#\n# An integer argument selects one element from the top-level array (starting at zero), changing the type by decreasing rank or jaggedness by one level.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6, 7.7, 8.8], [9.9]])\na[0]\n# array([1.1, 2.2, 3.3])\n\n# %%markdown\n# Negative indexes count backward from the last element,\n\n# %%\na[-1]\n# array([9.9])\n\n# %%markdown\n# and the index (after translating negative indexes) must be at least zero and less than the length of the top-level array.\n\n# %%\ntry:\n    a[-6]\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'IndexError'> index -6 is out of bounds for axis 0 with size 5\n\n# %%markdown\n# A slice selects a range of elements from the top-level array, maintaining the array's type. The first index is the inclusive starting point (starting at zero) and the second index is the exclusive endpoint.\n\n# %%\na[2:4]\n# <JaggedArray [[4.4 5.5] [6.6 7.7 8.8]] at 0x7811883f8390>\n\n# %%markdown\n# Python's slice syntax (above) or literal ``slice`` objects may be used.\n\n# %%\na[slice(2, 4)]\n# <JaggedArray [[4.4 5.5] [6.6 7.7 8.8]] at 0x7811883f8630>\n\n# %%markdown\n# Negative indexes count backward from the last element and endpoints may be omitted.\n\n# %%\na[-2:]\n# <JaggedArray [[6.6 7.7 8.8] [9.9]] at 0x7811883f8978>\n\n# %%markdown\n# Start and endpoints beyond the array are not errors: they are truncated.\n\n# %%\na[2:100]\n# <JaggedArray [[4.4 5.5] [6.6 7.7 8.8] [9.9]] at 0x7811883f8be0>\n\n# %%markdown\n# A skip value (third index of the slice) sets the stride for indexing, allowing you to skip elements, and this skip can be negative. It cannot, however, be zero.\n\n# %%\na[::-1]\n# <JaggedArray [[9.9] [6.6 7.7 8.8] [4.4 5.5] [] [1.1 2.2 3.3]] at 0x7811883f8ef0>\n\n# %%markdown\n# A Numpy array-like of booleans with the same length as the array may be used to filter elements. Numpy has a specialized `numpy.compress <https://docs.scipy.org/doc/numpy/reference/generated/numpy.compress.html>`__ function for this operation, but the only way to get it in awkward-array is through square brackets.\n\n# %%\na[[True, True, False, True, False]]\n# <JaggedArray [[1.1 2.2 3.3] [] [6.6 7.7 8.8]] at 0x781188407278>\n\n# %%markdown\n# A Numpy array-like of integers with the same length as the array may be used to select a collection of indexes. Numpy has a specialized `numpy.take <https://docs.scipy.org/doc/numpy/reference/generated/numpy.take.html>`__ function for this operation, but the only way to get it in awkward-array is through square brakets. Negative indexes and repeated elements are handled in the same way as Numpy.\n\n# %%\na[[-1, 0, 1, 2, 2, 2]]\n# <JaggedArray [[9.9] [1.1 2.2 3.3] [] [4.4 5.5] [4.4 5.5] [4.4 5.5]] at 0x781188407550>\n\n# %%markdown\n# A tuple of length ``N`` applies selections to the first ``N`` levels of rank or jaggedness. Our example array has only two levels, so we can apply two kinds of indexes.\n\n# %%\na[2:, 0]\n# array([4.4, 6.6, 9.9])\n\n# %%\na[[True, False, True, True, False], ::-1]\n# <JaggedArray [[3.3 2.2 1.1] [5.5 4.4] [8.8 7.7 6.6]] at 0x7811884079e8>\n\n# %%\na[[0, 3, 0], 1::]\n# <JaggedArray [[2.2 3.3] [7.7 8.8] [2.2 3.3]] at 0x781188407cc0>\n\n# %%markdown\n# As described in Numpy's `advanced indexing <https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html#advanced-indexing>`__, advanced indexes (boolean or integer arrays) are broadcast and iterated as one:\n\n# %%\na[[0, 3], [True, False, True]]\n# array([1.1, 8.8])\n\n# %%markdown\n# Awkward array has two extensions beyond Numpy, both of which affect only jagged data. If an array is jagged and a jagged array of booleans with the same structure (same length at all levels) is passed in square brackets, only inner arrays would be filtered.\n\n# %%\na    = awkward.fromiter([[  1.1,   2.2,  3.3], [], [ 4.4,  5.5], [ 6.6,  7.7,   8.8], [  9.9]])\nmask = awkward.fromiter([[False, False, True], [], [True, True], [True, True, False], [False]])\na[mask]\n# <JaggedArray [[3.3] [] [4.4 5.5] [6.6 7.7] []] at 0x7811883f8f60>\n\n# %%markdown\n# Similarly, if an array is jagged and a jagged array of integers with the same structure is passed in square brackets, only inner arrays would be filtered/duplicated/rearranged.\n\n# %%\na     = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6, 7.7, 8.8], [9.9]])\nindex = awkward.fromiter([[2, 2, 2, 2], [], [1, 0], [2, 1, 0], []])\na[index]\n# <JaggedArray [[3.3 3.3 3.3 3.3] [] [5.5 4.4] [8.8 7.7 6.6] []] at 0x78118847acf8>\n\n# %%markdown\n# Although all of the above use a ``JaggedArray`` as an example, the principles are general: you should get analogous results with jagged tables, masked jagged arrays, etc. Non-jagged arrays only support Numpy-like slicing.\n#\n# If an array contains a ``Table``, it can be selected with a string or a sequence of strings, just like Numpy `record arrays <https://docs.scipy.org/doc/numpy/user/basics.rec.html>`__.\n\n# %%\na = awkward.fromiter([{\"x\": 1, \"y\": 1.1, \"z\": \"one\"}, {\"x\": 2, \"y\": 2.2, \"z\": \"two\"}, {\"x\": 3, \"y\": 3.3, \"z\": \"three\"}])\na\n# <Table [<Row 0> <Row 1> <Row 2>] at 0x7811883930f0>\n\n# %%\na[\"x\"]\n# array([1, 2, 3])\n\n# %%\na[[\"z\", \"y\"]].tolist()\n# [{'z': 'one', 'y': 1.1}, {'z': 'two', 'y': 2.2}, {'z': 'three', 'y': 3.3}]\n\n# %%markdown\n# Like Numpy, integer indexes and string indexes commute if the integer index corresponds to a structure outside the ``Table`` (this condition is always met for Numpy record arrays).\n\n# %%\na[\"y\"][1]\n# 2.2\n\n# %%\na[1][\"y\"]\n# 2.2\n\n# %%\na = awkward.fromiter([[{\"x\": 1, \"y\": 1.1, \"z\": \"one\"}, {\"x\": 2, \"y\": 2.2, \"z\": \"two\"}], [], [{\"x\": 3, \"y\": 3.3, \"z\": \"three\"}]])\na\n# <JaggedArray [[<Row 0> <Row 1>] [] [<Row 2>]] at 0x781188407358>\n\n# %%\na[\"y\"][0][1]\n# 2.2\n\n# %%\na[0][\"y\"][1]\n# 2.2\n\n# %%\na[0][1][\"y\"]\n# 2.2\n\n# %%markdown\n# but not\n\n# %%\na = awkward.fromiter([{\"x\": 1, \"y\": [1.1]}, {\"x\": 2, \"y\": [2.1, 2.2]}, {\"x\": 3, \"y\": [3.1, 3.2, 3.3]}])\na\n# <Table [<Row 0> <Row 1> <Row 2>] at 0x7811883934a8>\n\n# %%\na[\"y\"][2][1]\n# 3.2\n\n# %%\na[2][\"y\"][1]\n# 3.2\n\n# %%\ntry:\n    a[2][1][\"y\"]\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'AttributeError'> no column named '_util_isstringslice'\n\n# %%markdown\nbecause\n\n# %%\na[2].tolist()\n# {'x': 3, 'y': [3.1, 3.2, 3.3]}\n\n# %%markdown\n# cannot take a ``1`` argument before ``\"y\"``.\n#\n# Just as integer indexes can be alternated with string/sequence of string indexes, so can slices, arrays, and tuples of slices and arrays.\n\n# %%\na[\"y\"][:, 0]\n# array([1.1, 2.1, 3.1])\n\n# %%markdown\n# Generally speaking, string and sequence of string indexes are *column* indexes, while all other types are *row* indexes.\n\n# %%markdown\n# ## Assigning with square brackets\n#\n# As discussed above, awkward arrays are generally immutable with few exceptions. Row assignment is only possible via appending to an ``AppendableArray``. Column assignment, reassignment, and deletion are in general allowed. The syntax for assigning and reassigning columns is through assignment to a square bracket expression. This operation is defined by Python's ``__setitem__`` method. The syntax for deleting columns is through the ``del`` operators on a square bracket expression. This operation is defined by Python's ``__delitem__`` method.\n#\n# Since only columns can be changed, only strings and sequences of strings are allowed as indexes.\n\n# %%\na = awkward.fromiter([[{\"x\": 1, \"y\": 1.1, \"z\": \"one\"}, {\"x\": 2, \"y\": 2.2, \"z\": \"two\"}], [], [{\"x\": 3, \"y\": 3.3, \"z\": \"three\"}]])\na\n# <JaggedArray [[<Row 0> <Row 1>] [] [<Row 2>]] at 0x7811883905c0>\n\n# %%\na[\"a\"] = awkward.fromiter([[100, 200], [], [300]])\na.tolist()\n# [[{'x': 1, 'y': 1.1, 'z': 'one', 'a': 100},\n#   {'x': 2, 'y': 2.2, 'z': 'two', 'a': 200}],\n#  [],\n#  [{'x': 3, 'y': 3.3, 'z': 'three', 'a': 300}]]\n\n# %%\ndel a[\"a\"]\na.tolist()\n# [[{'x': 1, 'y': 1.1, 'z': 'one'}, {'x': 2, 'y': 2.2, 'z': 'two'}],\n#  [],\n#  [{'x': 3, 'y': 3.3, 'z': 'three'}]]\n\n# %%\na[[\"a\", \"b\"]] = awkward.fromiter([[{\"first\": 100, \"second\": 111}, {\"first\": 200, \"second\": 222}], [], [{\"first\": 300, \"second\": 333}]])\na.tolist()\n# [[{'x': 1, 'y': 1.1, 'z': 'one', 'a': 100, 'b': 111},\n#   {'x': 2, 'y': 2.2, 'z': 'two', 'a': 200, 'b': 222}],\n#  [],\n#  [{'x': 3, 'y': 3.3, 'z': 'three', 'a': 300, 'b': 333}]]\n\n# %%markdown\n# Note that the names of the columns on the right-hand side of the assignment are irrelevant; we're setting two columns, there needs to be two columns on the right. Columns can be anonymous:\n\n# %%\na[[\"a\", \"b\"]] = awkward.Table(awkward.fromiter([[100, 200], [], [300]]), awkward.fromiter([[111, 222], [], [333]]))\na.tolist()\n# [[{'x': 1, 'y': 1.1, 'z': 'one', 'a': 100, 'b': 111},\n#   {'x': 2, 'y': 2.2, 'z': 'two', 'a': 200, 'b': 222}],\n#  [],\n#  [{'x': 3, 'y': 3.3, 'z': 'three', 'a': 300, 'b': 333}]]\n\n# %%markdown\n# Another thing to note is that the structure (lengths at all levels of jaggedness) must match if the depth is the same.\n\n# %%\ntry:\n    a[\"c\"] = awkward.fromiter([[100, 200, 300], [400], [500, 600]])\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'ValueError'> cannot broadcast JaggedArray to match JaggedArray with a different counts\n\n# %%markdown\n# But if the right-hand side is shallower and can be *broadcasted* to the left-hand side, it will be. (See below for broadcasting.)\n\n# %%\na[\"c\"] = awkward.fromiter([100, 200, 300])\na.tolist()\n# [[{'x': 1, 'y': 1.1, 'z': 'one', 'a': 100, 'b': 111, 'c': 100},\n#   {'x': 2, 'y': 2.2, 'z': 'two', 'a': 200, 'b': 222, 'c': 100}],\n#  [],\n#  [{'x': 3, 'y': 3.3, 'z': 'three', 'a': 300, 'b': 333, 'c': 300}]]\n\n# %%markdown\n# ## Numpy-like broadcasting\n#\n# In assignments and mathematical operations between higher-rank and lower-rank arrays, Numpy repeats values in the lower-rank array to \"fit,\" if possible, before applying the operation. This is called `boradcasting <https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html>`__. For example,\n\n# %%\nnumpy.array([[1.1, 2.2, 3.3], [4.4, 5.5, 6.6]]) + 100\n# array([[101.1, 102.2, 103.3],\n#        [104.4, 105.5, 106.6]])\n\n# %%markdown\nSingletons are also expanded to fit.\n\n# %%\nnumpy.array([[1.1, 2.2, 3.3], [4.4, 5.5, 6.6]]) + numpy.array([[100], [200]])\n# array([[101.1, 102.2, 103.3],\n#        [204.4, 205.5, 206.6]])\n\n# %%markdown\n# Awkward arrays have the same feature, but this has particularly useful effects for jagged arrays. In an operation involving two arrays of different depths of jaggedness, the shallower one expands to fit the deeper one.\n\n# %%\nawkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]]) + awkward.fromiter([100, 200, 300])\n# <JaggedArray [[101.1 102.2 103.3] [] [304.4 305.5]] at 0x781188390940>\n\n# %%markdown\n# Note that the ``100`` was broadcasted to all three of the elements of the first inner array, ``200`` was broadcasted to no elements in the second inner array (because the second inner array is empty), and ``300`` was broadcasted to all two of the elements of the third inner array.\n#\n# This is the columnar equivalent to accessing a variable defined outside of an inner loop.\n\n# %%\njagged = [[1.1, 2.2, 3.3], [], [4.4, 5.5]]\nflat = [100, 200, 300]\nfor i in range(3):\n    for j in range(len(jagged[i])):\n        # j varies in this loop, but i is constant\n        print(i, j, jagged[i][j] + flat[i])\n# 0 0 101.1\n# 0 1 102.2\n# 0 2 103.3\n# 2 0 304.4\n# 2 1 305.5\n\n# %%markdown\n# Many translations of non-columnar code to columnar code has this form. It's often surprising to users that they don't have to do anything special to get this feature (e.g. ``cross``).\n\n# %%markdown\n# ## Support for Numpy universal functions (ufuncs)\n#\n# Numpy's key feature of array-at-a-time programming is mainly provided by \"universal functions\" or \"ufuncs.\" This is a special class of function that applies a scalars → scalar kernel independently to aligned elements of internal arrays to return a same-shape output array. That is, for a scalars → scalar function ``f(x1, ..., xN) → y``, the ufunc takes ``N`` input arrays of the same ``shape`` and returns one output array with that ``shape`` in which ``output[i] = f(input1[i], ..., inputN[i])`` for all ``i``.\n\n# %%\n# N = 1\nnumpy.sqrt(numpy.array([1, 4, 9, 16, 25]))\n# array([1., 2., 3., 4., 5.])\n\n# %%\n# N = 2\nnumpy.add(numpy.array([[1.1, 2.2], [3.3, 4.4]]), numpy.array([[100, 200], [300, 400]]))\n# array([[101.1, 202.2],\n#        [303.3, 404.4]])\n\n# %%markdown\n# Keep in mind that a ufunc is not simply a function that has this property, but a specially named class, deriving from a type in the Numpy library.\n\n# %%\nnumpy.sqrt, numpy.add\n# (<ufunc 'sqrt'>, <ufunc 'add'>)\n\n# %%\nisinstance(numpy.sqrt, numpy.ufunc), isinstance(numpy.add, numpy.ufunc)\n# (True, True)\n\n# %%markdown\n# This class of functions can be overridden, and awkward-array overrides them to recognize and properly handle awkward arrays.\n\n# %%\nnumpy.sqrt(awkward.fromiter([[1, 4, 9], [], [16, 25]]))\n# <JaggedArray [[1.0 2.0 3.0] [] [4.0 5.0]] at 0x7811883f88d0>\n\n# %%\nnumpy.add(awkward.fromiter([[[1.1], 2.2], [], [3.3, None]]), awkward.fromiter([[[100], 200], [], [None, 300]]))\n# <JaggedArray [[[101.1] 202.2] [] [None None]] at 0x7811883f8d68>\n\n# %%markdown\n# Only the primary action of the ufunc (``ufunc.__call__``) has been overridden; methods like ``ufunc.at``, ``ufunc.reduce``, and ``ufunc.reduceat`` are not supported. Also, the in-place ``out`` parameter is not supported because awkward array data cannot be changed in-place.\n#\n# For awkward arrays, the input arguments to a ufunc must all have the same structure or, if shallower, be broadcastable to the deepest structure. (See above for \"broadcasting.\") The scalar function is applied to elements at the same positions within this structure from different input arrays. The output array has this structure, populated by return values of the scalar function.\n#\n# * Rectangular arrays must have the same shape, just as in Numpy. A scalar can be broadcasted (expanded) to have the same shape as the arrays.\n# * Jagged arrays must have the same number of elements in all inner arrays. A rectangular array with the same outer shape (i.e. containing scalars instead of inner arrays) can be broadcasted to inner arrays with the same lengths.\n# * Tables must have the same sets of columns (though not necessarily in the same order). There is no broadcasting of missing columns.\n# * Missing values (``None`` from ``MaskedArrays``) transform to missing values in every ufunc. That is, ``None + 5`` is ``None``, ``None + None`` is ``None``, etc.\n# * Different data types (through a ``UnionArray``) must be compatible at every site where values are included in the calculation. For instance, input arrays may contain tables with different sets of columns, but all inputs at index ``i`` must have the same sets of columns as each other:\n\n# %%\nnumpy.add(awkward.fromiter([{\"x\": 1, \"y\": 1.1}, {\"y\": 1.1, \"z\": 100}]),\n          awkward.fromiter([{\"x\": 3, \"y\": 3.3}, {\"y\": 3.3, \"z\": 300}])).tolist()\n# [{'x': 4, 'y': 4.4}, {'y': 4.4, 'z': 400}]\n\n# %%markdown\n# Unary and binary operations on awkward arrays, such as ``-x``, ``x + y``, and ``x**2``, are actually Numpy ufuncs, so all of the above applies to them as well (such as broadcasting the scalar ``2`` in ``x**2``).\n#\n# Remember that only ufuncs have been overridden by awkward-array: other Numpy functions such as ``numpy.concatenate`` are ignorant of awkward arrays and will attempt to convert them to Numpy first. In some cases, that may be what you want, but in many, especially any cases involving jagged arrays, it will be a major performance loss and a loss of functionality: jagged arrays turn into Numpy ``dtype=object`` arrays containing Numpy arrays, which can be a very large number of Python objects and doesn't behave as a multidimensional array.\n#\n# You can check to see if a function from Numpy is a ufunc with ``isinstance``.\n\n# %%\nisinstance(numpy.concatenate, numpy.ufunc)\n# False\n\n# %%markdown\n# and you can prevent accidental conversions to Numpy by setting ``allow_tonumpy`` to ``False``, either on one array or globally on a whole class of awkward arrays. (See \"global switches\" below.)\n\n# %%\nx = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\ny = awkward.fromiter([[6.6, 7.7, 8.8], [9.9]])\nnumpy.concatenate([x, y])\n# array([array([1.1, 2.2, 3.3]), array([], dtype=float64),\n#        array([4.4, 5.5]), array([6.6, 7.7, 8.8]), array([9.9])],\n#       dtype=object)\n\n# %%\nx.allow_tonumpy = False\ntry:\n    numpy.concatenate([x, y])\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'RuntimeError'> awkward.array.base.AwkwardArray.allow_tonumpy is False; refusing to convert to Numpy\n\n# %%markdown\n# ## Global switches\n#\n# The ``AwkwardArray`` abstract base class has the following switches to turn off sometmes-undesirable behavior. These switches could be set on the ``AwkwardArray`` class itself, affecting all awkward arrays, or they could be set on a particular class like ``JaggedArray`` to only affect ``JaggedArray`` instances, or they could be set on a particular instance, to affect only that instance.\n#\n# * ``allow_tonumpy`` (default is ``True``); if ``False``, forbid any action that would convert an awkward array into a Numpy array (with a likely loss of performance and functionality).\n# * ``allow_iter`` (default is ``True``); if ``False``, forbid any action that would iterate over an awkward array in Python (except printing a few elements as part of its string representation).\n# * ``check_prop_valid`` (default is ``True``); if ``False``, skip the single-property validity checks in array constructors and when setting properties.\n# * ``check_whole_valid`` (default is ``True``); if ``False``, skip the whole-array validity checks that are typically called before methods that need them.\n\n# %%\nawkward.AwkwardArray.check_prop_valid\n# True\n\n# %%\nawkward.JaggedArray.check_whole_valid\n# True\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\nnumpy.array(a)\n# array([array([1.1, 2.2, 3.3]), array([], dtype=float64),\n#        array([4.4, 5.5])], dtype=object)\n\n# %%\na.allow_tonumpy = False\ntry:\n    numpy.array(a)\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'RuntimeError'> awkward.array.base.AwkwardArray.allow_tonumpy is False; refusing to convert to Numpy\n\n# %%\nlist(a)\n# [array([1.1, 2.2, 3.3]), array([], dtype=float64), array([4.4, 5.5])]\n\n# %%\na.allow_iter = False\ntry:\n    list(a)\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'RuntimeError'> awkward.array.base.AwkwardArray.allow_iter is False; refusing to iterate\n\n# %%\na\n# <JaggedArray [[1.1 2.2 3.3] [] [4.4 5.5]] at 0x78118847ae10>\n\n# %%markdown\n# ## Generic properties and methods\n#\n# All awkward arrays have the following properties and methods.\n\n# %%markdown\n# * ``type``: the high-level type of the array. (See below for a detailed description of high-level types.)\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\nb = awkward.fromiter([[1.1, 2.2, None, 3.3, None],\n                      [4.4, [5.5]],\n                      [{\"x\": 6, \"y\": {\"z\": 7}}, None, {\"x\": 8, \"y\": {\"z\": 9}}]\n                     ])\n\n# %%\na.type\n# ArrayType(3, inf, dtype('float64'))\n\n# %%\nprint(a.type)\n# [0, 3) -> [0, inf) -> float64\n\n# %%\nb.type\n# ArrayType(3, inf, OptionType(UnionType(dtype('float64'), ArrayType(inf, dtype('float64')), TableType(x=dtype('int64'), y=TableType(z=dtype('int64'))))))\n\n# %%\nprint(b.type)\n# [0, 3) -> [0, inf) -> ?((float64             |\n#                          [0, inf) -> float64 |\n#                          'x' -> int64\n#                          'y' -> 'z' -> int64 ))\n\n# %%markdown\n# * ``layout``: the low-level layout of the array. (See below for a detailed description of low-level layouts.)\n\n# %%\na.layout\n#  layout\n# [    ()] JaggedArray(starts=layout[0], stops=layout[1], content=layout[2])\n# [     0]   ndarray(shape=3, dtype=dtype('int64'))\n# [     1]   ndarray(shape=3, dtype=dtype('int64'))\n# [     2]   ndarray(shape=5, dtype=dtype('float64'))\n\n# %%\nb.layout\n#  layout\n# [           ()] JaggedArray(starts=layout[0], stops=layout[1], content=layout[2])\n# [            0]   ndarray(shape=3, dtype=dtype('int64'))\n# [            1]   ndarray(shape=3, dtype=dtype('int64'))\n# [            2]   IndexedMaskedArray(mask=layout[2, 0], content=layout[2, 1], maskedwhen=-1)\n# [         2, 0]     ndarray(shape=10, dtype=dtype('int64'))\n# [         2, 1]     UnionArray(tags=layout[2, 1, 0], index=layout[2, 1, 1], contents=[layout[2, 1, 2], layout[2, 1, 3], layout[2, 1, 4]])\n# [      2, 1, 0]       ndarray(shape=7, dtype=dtype('uint8'))\n# [      2, 1, 1]       ndarray(shape=7, dtype=dtype('int64'))\n# [      2, 1, 2]       ndarray(shape=4, dtype=dtype('float64'))\n# [      2, 1, 3]       JaggedArray(starts=layout[2, 1, 3, 0], stops=layout[2, 1, 3, 1], content=layout[2, 1, 3, 2])\n# [   2, 1, 3, 0]         ndarray(shape=1, dtype=dtype('int64'))\n# [   2, 1, 3, 1]         ndarray(shape=1, dtype=dtype('int64'))\n# [   2, 1, 3, 2]         ndarray(shape=1, dtype=dtype('float64'))\n# [      2, 1, 4]       Table(x=layout[2, 1, 4, 0], y=layout[2, 1, 4, 1])\n# [   2, 1, 4, 0]         ndarray(shape=2, dtype=dtype('int64'))\n# [   2, 1, 4, 1]         Table(z=layout[2, 1, 4, 1, 0])\n# [2, 1, 4, 1, 0]           ndarray(shape=2, dtype=dtype('int64'))\n\n# %%markdown\n# * ``dtype``: the `Numpy dtype <https://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html>`__ that this array would have if cast as a Numpy array. Numpy dtypes cannot fully specify awkward arrays: use the ``type`` for an analyst-friendly description of the data type or ``layout`` for details about how the arrays are represented.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\na.dtype   # the closest Numpy dtype to a jagged array is dtype=object ('O')\n# dtype('O')\n\n# %%\nnumpy.array(a)\n# array([array([1.1, 2.2, 3.3]), array([], dtype=float64),\n#        array([4.4, 5.5])], dtype=object)\n\n# %%markdown\n# * ``shape``: the `Numpy shape <https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.shape.html>`__ that this array would have if cast as a Numpy array. This only specifies the first regular dimensions, not any jagged dimensions or regular dimensions nested within awkward structures. The Python length (``__len__``) of the array is the first element of this ``shape``.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\na.shape\n# (3,)\n\n# %%\nlen(a)\n# 3\n\n# %%markdown\n# The following ``JaggedArray`` has two fixed-size dimensions at the top, followed by a jagged dimension inside of that. The shape only represents the first few dimensions.\n\n# %%\na = awkward.JaggedArray.fromcounts([[3, 0], [2, 4]], [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9])\na\n# <JaggedArray [[[1.1 2.2 3.3] []] [[4.4 5.5] [6.6 7.7 8.8 9.9]]] at 0x7811883bc0b8>\n\n# %%\na.shape\n# (2, 2)\n\n# %%\nlen(a)\n# 2\n\n# %%\nprint(a.type)\n# [0, 2) -> [0, 2) -> [0, inf) -> float64\n\n# %%markdown\n# Also, a dimension can effectively be fixed-size, but represented by a ``JaggedArray``. The ``shape`` does not encompass any dimensions represented by a ``JaggedArray``.\n\n# %%\n# Same structure, but it's JaggedArrays all the way down.\nb = a.structure1d()\nb\n# <JaggedArray [[[1.1 2.2 3.3] []] [[4.4 5.5] [6.6 7.7 8.8 9.9]]] at 0x781188407240>\n\n# %%\nb.shape\n# (2,)\n\n# %%markdown\n# * ``size``: the product of ``shape``, as in Numpy.\n\n# %%\na.shape\n# (2, 2)\n\n# %%\na.size\n# 4\n\n# %%markdown\n# * ``nbytes``: the total number of bytes in all memory buffers referenced by the array, not including bytes in Python objects (which are Python-implementation dependent, not even available in PyPy). Same as the Numpy property of the same name.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\na.nbytes\n# 72\n\n# %%\na.offsets.nbytes + a.content.nbytes\n# 72\n\n# %%markdown\n# * ``tolist()``: converts the array into Python objects: ``lists`` for arrays, ``dicts`` for table rows, ``tuples`` for table rows with anonymous fields and a ``rowname`` of ``\"tuple\"``, ``None`` for missing data, and Python objects from ``ObjectArrays``. This is an approximate inverse of ``awkward.fromiter``.\n\n# %%\nawkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]]).tolist()\n# [[1.1, 2.2, 3.3], [], [4.4, 5.5]]\n\n# %%\nawkward.fromiter([{\"x\": 1, \"y\": 1.1}, {\"x\": 2, \"y\": 2.2}, {\"x\": 3, \"y\": 3.3}]).tolist()\n# [{'x': 1, 'y': 1.1}, {'x': 2, 'y': 2.2}, {'x': 3, 'y': 3.3}]\n\n# %%\nawkward.Table.named(\"tuple\", [1, 2, 3], [1.1, 2.2, 3.3]).tolist()\n# [(1, 1.1), (2, 2.2), (3, 3.3)]\n\n# %%\nawkward.fromiter([[1.1, 2.2, None], [], [None, 3.3]]).tolist()\n# [[1.1, 2.2, None], [], [None, 3.3]]\n\n# %%\nclass Point:\n    def __init__(self, x, y):\n        self.x, self.y = x, y\n    def __repr__(self):\n        return f\"Point({self.x}, {self.y})\"\n\na = awkward.fromiter([[Point(1, 1.1), Point(2, 2.2), Point(3, 3.3)], [], [Point(4, 4.4), Point(5, 5.5)]])\na\n# <JaggedArray [[Point(1, 1.1) Point(2, 2.2) Point(3, 3.3)] [] [Point(4, 4.4) Point(5, 5.5)]] at 0x7811883bccf8>\n\n# %%\na.tolist()\n# [[Point(1, 1.1), Point(2, 2.2), Point(3, 3.3)],\n#  [],\n#  [Point(4, 4.4), Point(5, 5.5)]]\n\n# %%markdown\n# * ``valid(exception=False, message=False)``: manually invoke the whole-array validity checks on the top-level array (not recursively). With the default options, this function returns ``True`` if valid and ``False`` if not. If ``exception=True``, it returns nothing on success and raises the appropriate exception on failure. If ``message=True``, it returns ``None`` on success and the error string on failure. (TODO: ``recursive=True``?)\n\n# %%\na = awkward.JaggedArray.fromcounts([3, 0, 2], [1.1, 2.2, 3.3, 4.4])  # content array is too short\na.valid()\n# False\n\n# %%\ntry:\n    a.valid(exception=True)\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'ValueError'> maximum offset 5 is beyond the length of the content (4)\n\n# %%\na.valid(message=True)\n# \"<class 'ValueError'>: maximum offset 5 is beyond the length of the content (4)\"\n\n# %%markdown\n# * ``astype(dtype)``: convert *nested Numpy arrays* into the given type while maintaining awkward structure.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\na.astype(numpy.int32)\n# <JaggedArray [[1 2 3] [] [4 5]] at 0x7811883b9898>\n\n# %%markdown\n# * ``regular()``: convert the awkward array into a Numpy array and (unlike ``numpy.array(awkward_array)``) raise an error if it cannot be faithfully represented.\n\n# %%\n# This JaggedArray happens to have equal-sized inner arrays.\na = awkward.fromiter([[1.1, 2.2, 3.3], [4.4, 5.5, 6.6], [7.7, 8.8, 9.9]])\na\n# <JaggedArray [[1.1 2.2 3.3] [4.4 5.5 6.6] [7.7 8.8 9.9]] at 0x781188390240>\n\n# %%\na.regular()\n# array([[1.1, 2.2, 3.3],\n#        [4.4, 5.5, 6.6],\n#        [7.7, 8.8, 9.9]])\n\n# %%\n# This one does not.\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\na\n# <JaggedArray [[1.1 2.2 3.3] [] [4.4 5.5]] at 0x7811883b9c18>\n\n# %%\ntry:\n    a.regular()\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'ValueError'> jagged array is not regular: different elements have different counts\n\n# %%markdown\n# * ``copy(optional constructor arguments...)``: copy an awkward array object, non-recursively and without copying memory buffers, possibly replacing some of its parameters. If the class is an awkward subclass or has mix-in methods, they are propagated to the copy.\n\n# %%\nclass Special:\n    def get(self, index):\n        try:\n            return self[index]\n        except IndexError:\n            return None\n\nJaggedArrayMethods = awkward.Methods.mixin(Special, awkward.JaggedArray)\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\na.__class__ = JaggedArrayMethods\na\n# <JaggedArrayMethods [[1.1 2.2 3.3] [] [4.4 5.5]] at 0x7811883bc2b0>\n\n# %%\na.get(2)\n# array([4.4, 5.5])\n\n# %%\na.get(3)\n\n# %%\nb = a.copy(content=[100, 200, 300, 400, 500])\nb\n# <JaggedArrayMethods [[100 200 300] [] [400 500]] at 0x7811883c5908>\n\n# %%\nb.get(2)\n# array([400, 500])\n\n# %%\nb.get(3)\n\n# %%markdown\n# Internally, all the methods that return views of the array (like slicing) use ``copy`` to retain the special methods.\n\n# %%\nc = a[1:]\nc\n# <JaggedArrayMethods [[] [4.4 5.5]] at 0x7811883c5be0>\n\n# %%\nc.get(1)\n# array([4.4, 5.5])\n\n# %%\nc.get(2)\n\n# %%markdown\n# * ``deepcopy(optional constructor arguments...)``: like ``copy``, except that it recursively copies all internal structure, including memory buffers associated with Numpy arrays.\n\n# %%\nb = a.deepcopy(content=[100, 200, 300, 400, 500])\nb\n# <JaggedArrayMethods [[100 200 300] [] [400 500]] at 0x781188355748>\n\n# %%\n# Modify the structure of a (not recommended; this is a demo).\na.starts[0] = 1\na\n# <JaggedArrayMethods [[2.2 3.3] [] [4.4 5.5]] at 0x7811883bc2b0>\n\n# %%\n# But b is not modified. (If it were, it would start with 200.)\nb\n# <JaggedArrayMethods [[100 200 300] [] [400 500]] at 0x781188355748>\n\n# %%markdown\n# * ``empty_like(optional constructor arguments...)``\n# * ``zeros_like(optional constructor arguments...)``\n# * ``ones_like(optional constructor arguments...)``: recursively copies structure, replacing contents with new uninitialized buffers, new buffers full of zeros, or new buffers full of ones. Not usually used in analysis, but needed for implementation.\n\n# %%\nd = a.zeros_like()\nd\n# <JaggedArrayMethods [[0.0 0.0] [] [0.0 0.0]] at 0x7811883c59b0>\n\n# %%\ne = a.ones_like()\ne\n# <JaggedArrayMethods [[1.0 1.0] [] [1.0 1.0]] at 0x78118847a2b0>\n\n# %%markdown\n# ## Reducers\n#\n# All awkward arrays also have a complete set of reducer methods. Reducers can be found in Numpy as well (as array methods and as free-standing functions), but they're not called out as a special class the way that universal functions (\"ufuncs\") are. Reducers decrease the rank or jaggedness of an array by one dimension, replacing subarrays with scalars. Examples include ``sum``, ``min``, and ``max``, but any monoid (associative operation with an identity) can be a reducer.\n#\n# In awkward-array, reducers are only array methods (not free-standing functions) and unlike Numpy, they do not take an ``axis`` parameter. When a reducer is called at any level, it reduces the innermost dimension. (Since outer dimensions can be jagged, this is the only dimension that can be meaningfully reduced.)\n\n# %%\na = awkward.fromiter([[[[1, 2], [3]], [[4, 5]]], [[[], [6, 7, 8, 9]]]])\na\n# <JaggedArray [[[[1 2] [3]] [[4 5]]] [[[] [6 7 8 9]]]] at 0x7811883b9470>\n\n# %%\na.sum()\n# <JaggedArray [[[3 3] [9]] [[0 30]]] at 0x7811883bc4a8>\n\n# %%\na.sum().sum()\n# <JaggedArray [[6 9] [30]] at 0x7811883bc048>\n\n# %%\na.sum().sum().sum()\n# array([15, 30])\n\n# %%\na.sum().sum().sum().sum()\n# 45\n\n# %%markdown\n# In the following example, \"the deepest axis\" of different fields in the table are at different depths: singly jagged in ``\"x\"`` and doubly jagged array in ``\"y\"``. The ``sum`` reduces each depth by one, producing a flat array ``\"x\"`` and a singly jagged array in ``\"y\"``.\n\n# %%\na = awkward.fromiter([{\"x\": [], \"y\": [[0.1, 0.2], [], [0.3]]}, {\"x\": [1, 2, 3], \"y\": [[0.4], [], [0.5, 0.6]]}])\na.tolist()\n# [{'x': [], 'y': [[0.1, 0.2], [], [0.3]]},\n#  {'x': [1, 2, 3], 'y': [[0.4], [], [0.5, 0.6]]}]\n\n# %%\na.sum().tolist()\n[{'x': 0, 'y': [0.3, 0.0, 0.3]},\n {'x': 6, 'y': [0.4, 0.0, 1.1]}]\n\n# %%markdown\n# This sum cannot be reduced again because ``\"x\"`` is not jagged (would reduce to a scalar) and ``\"y\"`` is (would reduce to an array). The result cannot be scalar in one field (a single row, not a collection) and an array in another field (a collection).\n\n# %%\ntry:\n    a.sum().sum()\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'ValueError'> some Table columns are jagged and others are not\n\n# %%markdown\n# A table can be reduced if all of its fields are jagged or if all of its fields are not jagged; here's an example of the latter.\n\n# %%\na = awkward.fromiter([{\"x\": 1, \"y\": 1.1}, {\"x\": 2, \"y\": 2.2}, {\"x\": 3, \"y\": 3.3}])\na.tolist()\n# [{'x': 1, 'y': 1.1}, {'x': 2, 'y': 2.2}, {'x': 3, 'y': 3.3}]\n\n# %%\na.sum()\n# <sum {'x': 6, 'y': 6.6}>\n\n# %%markdown\n# The resulting object is a scalar row—for your convenience, it has been labeled with the reducer that produced it.\n\n# %%\nisinstance(a.sum(), awkward.Table.Row)\n# True\n\n# %%markdown\n# ``UnionArrays`` are even more constrained: they can only be reduced if they have primitive (Numpy) type.\n\n# %%\na = awkward.fromiter([1, 2, 3, {\"x\": 1, \"y\": 1.1}, {\"x\": 2, \"y\": 2.2}])\na\n# <UnionArray [1 2 3 <Row 0> <Row 1>] at 0x781188355550>\n\n# %%\ntry:\n    a.sum()\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'TypeError'> cannot reduce a UnionArray of non-primitive type\n\n# %%\na = awkward.UnionArray.fromtags([0, 0, 0, 1, 1],\n                                [numpy.array([1, 2, 3], dtype=numpy.int32),\n                                 numpy.array([4, 5], dtype=numpy.float64)])\na\n# <UnionArray [1 2 3 4.0 5.0] at 0x781188355da0>\n\n# %%\na.sum()\n# 15.0\n\n# %%markdown\n# In all reducers, ``NaN`` in floating-point arrays and ``None`` in ``MaskedArrays`` are skipped, so these reducers are more like ``numpy.nansum``, ``numpy.nanmax``, and ``numpy.nanmin``, but generalized to all nullable types.\n\n# %%\na = awkward.fromiter([[[[1.1, numpy.nan], [2.2]], [[None, 3.3]]], [[[], [None, numpy.nan, None]]]])\na\n# <JaggedArray [[[[1.1 nan] [2.2]] [[None 3.3]]] [[[] [None nan None]]]] at 0x78118835c7b8>\n\n# %%\na.sum()\n# <JaggedArray [[[1.1 2.2] [3.3]] [[0.0 0.0]]] at 0x781188355a20>\n\n# %%\na = awkward.fromiter([[{\"x\": 1, \"y\": 1.1}, None, {\"x\": 3, \"y\": 3.3}], [], [{\"x\": 4, \"y\": numpy.nan}]])\na.tolist()\n# [[{'x': 1, 'y': 1.1}, None, {'x': 3, 'y': 3.3}], [], [{'x': 4, 'y': nan}]]\n\n# %%\na.sum().tolist()\n# [{'x': 4, 'y': 4.4}, {'x': 0, 'y': 0.0}, {'x': 4, 'y': 0.0}]\n\n# %%markdown\n# The following reducers are defined as methods on all awkward arrays.\n\n# %%markdown\n# * ``reduce(ufunc, identity)``: generic reducer, calls ``ufunc.reduceat`` and returns ``identity`` for empty arrays.\n\n# %%\n# numba.vectorize makes new ufuncs (requires type signatures and a kernel function)\nimport numba\n@numba.vectorize([numba.int64(numba.int64, numba.int64)])\ndef sum_mod_10(x, y):\n    return (x + y) % 10\n\n# %%\na = awkward.fromiter([[1, 2, 3], [], [4, 5, 6], [7, 8, 9, 10]])\na.sum()\n# array([ 6,  0, 15, 34])\n\n# %%\na.reduce(sum_mod_10, 0)\n# array([6, 0, 5, 4])\n\n# %%\n# Missing (None) values are ignored.\na = awkward.fromiter([[1, 2, None, 3], [], [None, None, None], [7, 8, 9, 10]])\na.reduce(sum_mod_10, 0)\n# array([6, 0, 0, 4])\n\n# %%markdown\n# * ``any()``: boolean reducer, returns ``True`` if any (logical or) of the elements of an array are ``True``, returns ``False`` for empty arrays.\n\n# %%\na = awkward.fromiter([[False, False], [True, True], [True, False], []])\na.any()\n# array([False,  True,  True, False])\n\n# %%\n# Missing (None) values are ignored.\na = awkward.fromiter([[False, None], [True, None], [None]])\na.any()\n# array([False,  True, False])\n\n# %%markdown\n# * ``all()``: boolean reducer, returns ``True`` if all (logical and) of the elements of an array are ``True``, returns ``True`` for empty arrays.\n\n# %%\na = awkward.fromiter([[False, False], [True, True], [True, False], []])\na.all()\n# array([False,  True, False,  True])\n\n# %%\n# Missing (None) values are ignored.\na = awkward.fromiter([[False, None], [True, None], [None]])\na.all()\n# array([False,  True,  True])\n\n# %%markdown\n# * ``count()``: returns the (integer) number of elements in an array, skipping ``None`` and ``NaN``.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, None], [], [3.3, numpy.nan]])\na.count()\n# array([2, 0, 1])\n\n# %%markdown\n# * ``count_nonzero()``: returns the (integer) number of non-zero elements in an array, skipping ``None`` and ``NaN``.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, None, 0], [], [3.3, numpy.nan, 0]])\na.count_nonzero()\n# array([2, 0, 1])\n\n# %%markdown\n# * ``sum()``: returns the sum of each array, skipping ``None`` and ``NaN``, returning 0 for empty arrays.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, None], [], [3.3, numpy.nan]])\na.sum()\n# array([3.3, 0. , 3.3])\n\n# %%markdown\n# * ``prod()``: returns the product (multiplication) of each array, skipping ``None`` and ``NaN``, returning 1 for empty arrays.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, None], [], [3.3, numpy.nan]])\na.prod()\n# array([2.42, 1.  , 3.3 ])\n\n# %%markdown\n# * ``min()``: returns the minimum number in each array, skipping ``None`` and ``NaN``, returning infinity or the largest possible integer for empty arrays. (Note that Numpy raises errors for empty arrays.)\n\n# %%\na = awkward.fromiter([[1.1, 2.2, None], [], [3.3, numpy.nan]])\na.min()\n# array([1.1, inf, 3.3])\n\n# %%\na = awkward.fromiter([[1, 2, None], [], [3]])\na.min()\n# array([                  1, 9223372036854775807,                   3])\n\n# %%markdown\n# The identity of minimization is ``inf`` for floating-point values and ``9223372036854775807`` for ``int64`` because minimization with any other value would return the other value. This is more convenient for data analysts than raising an error because empty inner arrays are common.\n\n# %%markdown\n# * ``max()``: returns the maximum number in each array, skipping ``None`` and ``NaN``, returning negative infinity or the smallest possible integer for empty arrays. (Note that Numpy raises errors for empty arrays.)\n\n# %%\na = awkward.fromiter([[1.1, 2.2, None], [], [3.3, numpy.nan]])\na.max()\n# array([ 2.2, -inf,  3.3])\n\n# %%\na = awkward.fromiter([[1, 2, None], [], [3]])\na.max()\n# array([                   2, -9223372036854775808,                    3])\n\n# %%markdown\n# The identity of maximization is ``-inf`` for floating-point values and ``-9223372036854775808`` for ``int64`` because maximization with any other value would return the other value. This is more convenient for data analysts than raising an error because empty inner arrays are common.\n#\n# Note that the maximization-identity for unsigned types is ``0``.\n\n# %%\na = awkward.JaggedArray.fromcounts([3, 0, 2], numpy.array([1.1, 2.2, 3.3, 4.4, 5.5], dtype=numpy.uint16))\na\n# <JaggedArray [[1 2 3] [] [4 5]] at 0x78112c0e9a58>\n\n# %%\na.max()\n# array([3, 0, 5], dtype=uint16)\n\n# %%markdown\n# Functions like mean and standard deviation aren't true reducers because they're not associative (``mean(mean(x1, x2, x3), mean(x4, x5))`` is not equal to ``mean(mean(x1, x2), mean(x3, x4, x5))``). However, they're useful methods that exist on all awkward arrays, defined in terms of reducers.\n\n# %%markdown\n# * ``moment(n, weight=None)``: returns the ``n``th moment of each array (a floating-point value), skipping ``None`` and ``NaN``, returning ``NaN`` for empty arrays. If ``weight`` is given, it is taken as an array of weights, which may have the same structure as the ``array`` or be broadcastable to it, though any broadcasted weights would have no effect on the moment.\n\n# %%\na = awkward.fromiter([[1, 2, 3], [], [4, 5]])\n\n# %%\na.moment(1)\n# array([2. , nan, 4.5])\n\n# %%\na.moment(2)\n# array([ 4.66666667,         nan, 20.5       ])\n\n# %%markdown\n# Here is the first moment (mean) with a weight broadcasted from a scalar and from a non-jagged array, to show how it doesn't affect the result. The moment is calculated over an inner array, so if a constant value is broadcasted to all elements of that inner array, they all get the same weight.\n\n# %%\na.moment(1)\n# array([2. , nan, 4.5])\n\n# %%\na.moment(1, 100)\n# array([2. , nan, 4.5])\n\n# %%\na.moment(1, numpy.array([100, 200, 300]))\n# array([2. , nan, 4.5])\n\n# %%markdown\n# Only when the weight varies across an inner array does it have an effect.\n\n# %%\na.moment(1, awkward.fromiter([[1, 10, 100], [], [0, 100]]))\n# array([2.89189189,        nan, 5.        ])\n\n# %%markdown\n# * ``mean(weight=None)``: returns the mean of each array (a floating-point value), skipping ``None`` and ``NaN``, returning ``NaN`` for empty arrays, using optional ``weight`` as above.\n\n# %%\na = awkward.fromiter([[1, 2, 3], [], [4, 5]])\na.mean()\n# array([2. , nan, 4.5])\n\n# %%markdown\n# * ``var(weight=None, ddof=0)``: returns the variance of each array (a floating-point value), skipping ``None`` and ``NaN``, returning ``NaN`` for empty arrays, using optional ``weight`` as above. The ``ddof`` or \"Delta Degrees of Freedom\" replaces a divisor of ``N`` (count or sum of weights) with a divisor of ``N - ddof``, following `numpy.var <https://docs.scipy.org/doc/numpy/reference/generated/numpy.var.html>`__.\n\n# %%\na = awkward.fromiter([[1, 2, 3], [], [4, 5]])\na.var()\n# array([0.66666667,        nan, 0.25      ])\n\n# %%\na.var(ddof=1)\n# array([1. , nan, 0.5])\n\n# %%markdown\n# * ``std(weight=None, ddof=0)``: returns the standard deviation of each array, the square root of the variance described above.\n\n# %%\na.std()\n# array([0.81649658,        nan, 0.5       ])\n\n# %%\na.std(ddof=1)\n# array([1.        ,        nan, 0.70710678])\n\n# %%markdown\n# ## Properties and methods for jaggedness\n#\n# All awkward arrays have these methods, but they provide information about the first nested ``JaggedArray`` within a structure. If, for instance, the ``JaggedArray`` is within some structure that doesn't affect high-level type (e.g. ``IndexedArray``, ``ChunkedArray``, ``VirtualArray``), then the methods are passed through to the ``JaggedArray``. If it's nested within something that does change type, but can meaningfully pass on the call, such as ``MaskedArray``, then that's what they do. If, however, it reaches a ``Table``, which may have some jagged columns and some non-jagged columns, the propagation stops.\n#\n# * ``counts``: Numpy array of the number of elements in each inner array of the shallowest ``JaggedArray``. The ``counts`` may have rank > 1 if there are any fixed-size dimensions before the ``JaggedArray``.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6, 7.7, 8.8, 9.9]])\na.counts\n# array([3, 0, 2, 4])\n\n# %%\n# MaskedArrays return -1 for missing values.\na = awkward.fromiter([[1.1, 2.2, 3.3], [], None, [6.6, 7.7, 8.8, 9.9]])\na.counts\n# array([ 3,  0, -1,  4])\n\n# %%markdown\n# A missing inner array (counts is ``-1``) is distinct from an empty inner array (counts is ``0``), but if you want to ensure that you're working with data that have at least ``N`` elements, ``counts >= N`` works.\n\n# %%\na.counts >= 1\n# array([ True, False, False,  True])\n\n# %%\na[a.counts >= 1]\n# <MaskedArray [[1.1 2.2 3.3] [6.6 7.7 8.8 9.9]] at 0x78112c0d54a8>\n\n# %%\n# UnionArrays return -1 for non-jagged arrays mixed with jagged arrays.\na = awkward.fromiter([[1.1, 2.2, 3.3], [], 999, [6.6, 7.7, 8.8, 9.9]])\na.counts\n# array([ 3,  0, -1,  4])\n\n# %%\n# Same for tabular data, regardless of whether they contain nested jagged arrays.\na = awkward.fromiter([[1.1, 2.2, 3.3], [], {\"x\": 1, \"y\": [1.1, 1.2, 1.3]}, [6.6, 7.7, 8.8, 9.9]])\na.counts\n# array([ 3,  0, -1,  4])\n\n# %%markdown\n# Note! This means that pure ``Tables`` will always return zeros for counts, regardless of what they contain.\n\n# %%\na = awkward.fromiter([{\"x\": [], \"y\": []}, {\"x\": [1], \"y\": [1.1]}, {\"x\": [1, 2], \"y\": [1.1, 2.2]}])\na.counts\n# array([-1, -1, -1])\n\n# %%markdown\n# If all of the columns of a ``Table`` are ``JaggedArrays`` with the same structure, you probably want to zip them into a single ``JaggedArray``.\n\n# %%\nb = awkward.JaggedArray.zip(x=a.x, y=a.y)\nb\n# <JaggedArray [[] [<Row 0>] [<Row 1> <Row 2>]] at 0x78112c0dc7f0>\n\n# %%\nb.counts\n# array([0, 1, 2])\n\n# %%markdown\n# * ``flatten(axis=0)``: removes one level of structure (losing information about boundaries between inner arrays) at a depth of jaggedness given by ``axis``.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6, 7.7, 8.8, 9.9]])\na.flatten()\n# array([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9])\n\n# %%markdown\n# Unlike a ``JaggedArray``'s ``content``, which is part of its low-level layout, ``flatten()`` performs a high-level logical operation. Here's an example of the distinction.\n\n# %%\n# JaggedArray with an unusual but valid structure.\na = awkward.JaggedArray([3, 100, 0, 6], [6, 100, 2, 10],\n                        [4.4, 5.5, 999, 1.1, 2.2, 3.3, 6.6, 7.7, 8.8, 9.9, 123])\na\n# <JaggedArray [[1.1 2.2 3.3] [] [4.4 5.5] [6.6 7.7 8.8 9.9]] at 0x78112c127cf8>\n\n# %%\na.flatten()   # gives you a logically flattened array\n# array([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9])\n\n# %%\na.content     # gives you an internal structure component of the array\n# array([  4.4,   5.5, 999. ,   1.1,   2.2,   3.3,   6.6,   7.7,   8.8,\n#          9.9, 123. ])\n\n# %%markdown\n# In many cases, the output of ``flatten()`` corresponds to the output of ``content``, but be aware of the difference and use the one you want.\n#\n# With ``flatten(axis=1)``, we can internally flatten nested ``JaggedArrays``.\n\n# %%\na = awkward.fromiter([[[1.1, 2.2], [3.3]], [], [[4.4, 5.5]], [[6.6, 7.7, 8.8], [], [9.9]]])\na\n# <JaggedArray [[[1.1 2.2] [3.3]] [] [[4.4 5.5]] [[6.6 7.7 8.8] [] [9.9]]] at 0x78112c127208>\n\n# %%\na.flatten(axis=0)\n# <JaggedArray [[1.1 2.2] [3.3] [4.4 5.5] [6.6 7.7 8.8] [] [9.9]] at 0x78112c1276a0>\n\n# %%\na.flatten(axis=1)\n# <JaggedArray [[1.1 2.2 3.3] [] [4.4 5.5] [6.6 7.7 8.8 9.9]] at 0x78112c127320>\n\n# %%markdown\n# Even if a ``JaggedArray``'s inner structure is due to a fixed-shape Numpy array, the ``axis`` parameter propagates down and does the right thing.\n\n# %%\na = awkward.JaggedArray.fromcounts(numpy.array([3, 0, 2]),\n                                   numpy.array([[1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]))\na\n# <JaggedArray [[[1 1] [2 2] [3 3]] [] [[4 4] [5 5]]] at 0x78112c0d5ac8>\n\n# %%\ntype(a.content)\n# numpy.ndarray\n\n# %%\na.flatten(axis=1)\n# <JaggedArray [[1 1 2 2 3 3] [] [4 4 5 5]] at 0x78112c0d5a20>\n\n# %%markdown\n# But, unlike Numpy, we can't ask for an ``axis`` starting from the other end (with a negative index). The \"deepest array\" is not a well-defined concept for awkward arrays.\n\n# %%\ntry:\n    a.flatten(axis=-1)\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'TypeError'> axis must be a non-negative integer (can't count from the end)\n\n# %%\na = awkward.fromiter([[[1.1, 2.2], [3.3]], [], None, [[6.6, 7.7, 8.8], [], [9.9]]])\na\n# <MaskedArray [[[1.1 2.2] [3.3]] [] None [[6.6 7.7 8.8] [] [9.9]]] at 0x78112c0d51d0>\n\n# %%\na.flatten(axis=1)\n# <JaggedArray [[1.1 2.2 3.3] [] [6.6 7.7 8.8 9.9]] at 0x78112c0dcfd0>\n\n# %%markdown\n# * ``pad(length, maskedwhen=True, clip=False)``: ensures that each inner array has at least ``length`` elements by filling in the empty spaces with ``None`` (i.e. by inserting a ``MaskedArray`` layer). The ``maskedwhen`` parameter determines whether ``mask[i] == True`` means the element is ``None`` (``maskedwhen=True``) or not ``None`` (``maskedwhen=False``). Setting ``maskedwhen`` doesn't change the logical meaning of the array. If ``clip=True``, then the inner arrays will have exactly ``length`` elements (by clipping the ones that are too long). Even though this results in regular sizes, they are still represented by a ``JaggedArray``.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6, 7.7, 8.8, 9.9]])\na\n# <JaggedArray [[1.1 2.2 3.3] [] [4.4 5.5] [6.6 7.7 8.8 9.9]] at 0x78112c127be0>\n\n# %%\na.pad(3)\n# <JaggedArray [[1.1 2.2 3.3] [None None None] [4.4 5.5 None] [6.6 7.7 8.8 9.9]] at 0x78112c122588>\n\n# %%\na.pad(3, maskedwhen=False)\n# <JaggedArray [[1.1 2.2 3.3] [None None None] [4.4 5.5 None] [6.6 7.7 8.8 9.9]] at 0x78112c122c18>\n\n# %%\na.pad(3, clip=True)\n# <JaggedArray [[1.1 2.2 3.3] [None None None] [4.4 5.5 None] [6.6 7.7 8.8]] at 0x78112c127940>\n\n# %%markdown\n# If you want to get rid of the ``MaskedArray`` layer, replace ``None`` with some value.\n\n# %%\na.pad(3).fillna(-999)\n# <JaggedArray [[1.1 2.2 3.3] [-999.0 -999.0 -999.0] [4.4 5.5 -999.0] [6.6 7.7 8.8 9.9]] at 0x78112c0dc0b8>\n\n# %%markdown\n# If you want to make an effectively regular array into a real Numpy array, use ``regular``.\n\n# %%\na.pad(3, clip=True).fillna(0).regular()\n# array([[1.1, 2.2, 3.3],\n#        [0. , 0. , 0. ],\n#        [4.4, 5.5, 0. ],\n#        [6.6, 7.7, 8.8]])\n\n# %%markdown\n# If a ``JaggedArray`` is nested within some other type, ``pad`` will propagate down to it.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], None, [4.4, 5.5], None])\na\n# <MaskedArray [[1.1 2.2 3.3] [] None [4.4 5.5] None] at 0x78112c0d52b0>\n\n# %%\na.pad(3)\n# <MaskedArray [[1.1 2.2 3.3] [None None None] None [4.4 5.5 None] None] at 0x78112c0e9908>\n\n# %%\na = awkward.Table(x=[[1, 1], [2, 2], [3, 3], [4, 4]],\n                  y=awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6, 7.7, 8.8, 9.9]]))\na.tolist()\n# [{'x': [1, 1], 'y': [1.1, 2.2, 3.3]},\n#  {'x': [2, 2], 'y': []},\n#  {'x': [3, 3], 'y': [4.4, 5.5]},\n#  {'x': [4, 4], 'y': [6.6, 7.7, 8.8, 9.9]}]\n\n# %%\na.pad(3).tolist()\n# [{'x': [1, 1, None], 'y': [1.1, 2.2, 3.3]},\n#  {'x': [2, 2, None], 'y': [None, None, None]},\n#  {'x': [3, 3, None], 'y': [4.4, 5.5, None]},\n#  {'x': [4, 4, None], 'y': [6.6, 7.7, 8.8, 9.9]}]\n\n# %%\na.pad(3, clip=True).tolist()\n# [{'x': [1, 1, None], 'y': [1.1, 2.2, 3.3]},\n#  {'x': [2, 2, None], 'y': [None, None, None]},\n#  {'x': [3, 3, None], 'y': [4.4, 5.5, None]},\n#  {'x': [4, 4, None], 'y': [6.6, 7.7, 8.8]}]\n\n# %%markdown\n# If you pass a ``pad`` through a ``Table``, be sure that every field in each record is a nested array (and therefore can be padded).\n\n# %%\na = awkward.Table(x=[1, 2, 3, 4],\n                  y=awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6, 7.7, 8.8, 9.9]]))\na.tolist()\n# [{'x': 1, 'y': [1.1, 2.2, 3.3]},\n#  {'x': 2, 'y': []},\n#  {'x': 3, 'y': [4.4, 5.5]},\n#  {'x': 4, 'y': [6.6, 7.7, 8.8, 9.9]}]\n\n# %%\ntry:\n    a.pad(3)\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'ValueError'> pad cannot be applied to scalars\n\n# %%markdown\n# The same goes for ``UnionArrays``.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3, [1, 2, 3]], [], [4.4, 5.5, [4, 5]]])\na\n# <JaggedArray [[1.1 2.2 3.3 [1 2 3]] [] [4.4 5.5 [4 5]]] at 0x7811883c5d30>\n\n# %%\na.pad(5)\n# <JaggedArray [[1.1 2.2 3.3 [1 2 3] None] [None None None None None] [4.4 5.5 [4 5] None None]] at 0x78112c0e9a20>\n\n# %%\na = awkward.UnionArray.fromtags([0, 0, 0, 1, 1],\n                                [awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]]),\n                                 awkward.fromiter([[100, 101], [102]])])\na\n# <UnionArray [[1.1 2.2 3.3] [] [4.4 5.5] [100 101] [102]] at 0x78112c0bed30>\n\n# %%\na.pad(3)\n# <UnionArray [[1.1 2.2 3.3] [None None None] [4.4 5.5 None] [100 101 None] [102 None None]] at 0x78112c0bedd8>\n\n# %%\na = awkward.UnionArray.fromtags([0, 0, 0, 1, 1],\n                                [awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]]),\n                                 awkward.fromiter([100, 200])])\na\n# <UnionArray [[1.1 2.2 3.3] [] [4.4 5.5] 100 200] at 0x78112c0e9b00>\n\n# %%\ntry:\n    a.pad(3)\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'ValueError'> pad cannot be applied to scalars\n\n# %%markdown\n# The general behavior of ``pad`` is to replace the shallowest ``JaggedArray`` with a ``JaggedArray`` containing a ``MaskedArray``. The one exception to this type signature is that ``StringArrays`` are padded with characters.\n\n# %%\na = awkward.fromiter([\"one\", \"two\", \"three\"])\na\n# <StringArray ['one' 'two' 'three'] at 0x78112c0dcb00>\n\n# %%\na.pad(4, clip=True)\n# <StringArray ['one ' 'two ' 'thre'] at 0x78112c1222b0>\n\n# %%\na.pad(4, maskedwhen=b\".\", clip=True)\n# <StringArray ['one.' 'two.' 'thre'] at 0x78112c122f98>\n\n# %%\na.pad(4, maskedwhen=b\"\\x00\", clip=True)\n# <StringArray ['one\\x00' 'two\\x00' 'thre'] at 0x78112c122be0>\n\n# %%markdown\n# * ``argmin()`` and ``argmax()``: returns the index of the minimum or maximum value in a non-jagged array or the indexes where each inner array is minimized or maximized. The jagged structure of the return value consists of empty arrays for each empty array and singleton arrays for non-empty ones, consisting of a single index in an inner array. This is the form needed to extract one element from each inner array using jagged indexing.\n\n# %%\na = awkward.fromiter([[-3.3, 5.5, -8.8], [], [-6.6, 0.0, 2.2, 3.3], [], [2.2, -2.2, 4.4]])\nabsa = abs(a)\n\n# %%\na\n# <JaggedArray [[-3.3 5.5 -8.8] [] [-6.6 0.0 2.2 3.3] [] [2.2 -2.2 4.4]] at 0x78112c0beb70>\n\n# %%\nabsa\n# <JaggedArray [[3.3 5.5 8.8] [] [6.6 0.0 2.2 3.3] [] [2.2 2.2 4.4]] at 0x78112c0bec18>\n\n# %%\nindex = absa.argmax()\nindex\n# <JaggedArray [[2] [] [0] [] [2]] at 0x78112c0d0128>\n\n# %%\nabsa[index]\n# <JaggedArray [[8.8] [] [6.6] [] [4.4]] at 0x78112c122c50>\n\n# %%\na[index]\n# <JaggedArray [[-8.8] [] [-6.6] [] [4.4]] at 0x78112c0d5eb8>\n\n# %%markdown\n# * ``cross(other, nested=False)`` and ``argcross(other, nested=False)``: returns jagged tuples representing the `cross-join <https://en.wikipedia.org/wiki/Join_(SQL)#Cross_join>`__ of `array[i]` and `other[i]` separately for each `i`. If `nested=True`, the result is doubly jagged so that each element of the output corresponds to exactly one element in the original `array`.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6, 7.7, 8.8, 9.9]])\nb = awkward.fromiter([[\"one\", \"two\"], [\"three\"], [\"four\", \"five\", \"six\"], [\"seven\"]])\na.cross(b)\n# <JaggedArray [[(1.1, one) (1.1, two) (2.2, one) (2.2, two) (3.3, one) (3.3, two)] [] [(4.4, four) (4.4, five) (4.4, six) (5.5, four) (5.5, five) (5.5, six)] [(6.6, seven) (7.7, seven) (8.8, seven) (9.9, seven)]] at 0x78112c0e9550>\n\n# %%\na.cross(b, nested=True)\n# <JaggedArray [[[(1.1, one) (1.1, two)] [(2.2, one) (2.2, two)] [(3.3, one) (3.3, two)]] [] [[(4.4, four) (4.4, five) (4.4, six)] [(5.5, four) (5.5, five) (5.5, six)]] [[(6.6, seven)] [(7.7, seven)] [(8.8, seven)] [(9.9, seven)]]] at 0x78112c0be978>\n\n# %%markdown\n# The \"arg\" version returns indexes at which the appropriate objects may be found, as usual.\n\n# %%\na.argcross(b)\n# <JaggedArray [[(0, 0) (0, 1) (1, 0) (1, 1) (2, 0) (2, 1)] [] [(0, 0) (0, 1) (0, 2) (1, 0) (1, 1) (1, 2)] [(0, 0) (1, 0) (2, 0) (3, 0)]] at 0x78112c122470>\n\n# %%\na.argcross(b, nested=True)\n# <JaggedArray [[[(0, 0) (0, 1)] [(1, 0) (1, 1)] [(2, 0) (2, 1)]] [] [[(0, 0) (0, 1) (0, 2)] [(1, 0) (1, 1) (1, 2)]] [[(0, 0)] [(1, 0)] [(2, 0)] [(3, 0)]]] at 0x78112c122dd8>\n\n# %%markdown\n# This method is good to use with ``unzip``, which separates the ``Table`` of tuples into a left half and a right half.\n\n# %%\nleft, right = a.cross(b).unzip()\nleft, right\n# (<JaggedArray [[1.1 1.1 2.2 2.2 3.3 3.3] [] [4.4 4.4 4.4 5.5 5.5 5.5] [6.6 7.7 8.8 9.9]] at 0x78112c0be278>,\n#  <JaggedArray [['one' 'two' 'one' 'two' 'one' 'two'] [] ['four' 'five' 'six' 'four' 'five' 'six'] ['seven' 'seven' 'seven' 'seven']] at 0x78112c0d0470>)\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6, 7.7, 8.8, 9.9]])\nb = awkward.fromiter([[1, 2], [3], [4, 5, 6], [7]])\nleft, right = a.cross(b, nested=True).unzip()\nleft, right\n# (<JaggedArray [[[1.1 1.1] [2.2 2.2] [3.3 3.3]] [] [[4.4 4.4 4.4] [5.5 5.5 5.5]] [[6.6] [7.7] [8.8] [9.9]]] at 0x78112c127048>,\n#  <JaggedArray [[[1 2] [1 2] [1 2]] [] [[4 5 6] [4 5 6]] [[7] [7] [7] [7]]] at 0x78112c127630>)\n\n# %%markdown\n# This can be handy if a subsequent function takes two jagged arrays as arguments.\n\n# %%\ndistance = round(abs(left - right), 1)\ndistance\n# <JaggedArray [[[0.1 0.9] [1.2 0.2] [2.3 1.3]] [] [[0.4 0.6 1.6] [1.5 0.5 0.5]] [[0.4] [0.7] [1.8] [2.9]]] at 0x78112c0bec88>\n\n# %%markdown\n# Cross with ``nested=True``, followed by some calculation on the pairs and then some reducer, is a common pattern. Because of the ``nested=True`` and the reducer, the resulting array has the same structure as the original.\n\n# %%\ndistance.min()\n# <JaggedArray [[0.1 0.2 1.3] [] [0.4 0.5] [0.4 0.7 1.8 2.9]] at 0x78112c0d50f0>\n\n# %%\nround(a + distance.min(), 1)\n# <JaggedArray [[1.2 2.4 4.6] [] [4.8 6.0] [7.0 8.4 10.6 12.8]] at 0x78112c122518>\n\n# %%markdown\n# * ``pairs(nested=False)`` and ``argpairs(nested=False)``: returns jagged tuples representing the `self-join <https://en.wikipedia.org/wiki/Join_(SQL)#Self-join>`__ removing duplicates but not same-object pairs (i.e. a self-join with ``i1 <= i2``) for each inner array separately.\n\n# %%\na = awkward.fromiter([[\"a\", \"b\", \"c\"], [], [\"d\", \"e\"]])\na.pairs()\n# <JaggedArray [[(a, a) (a, b) (a, c) (b, b) (b, c) (c, c)] [] [(d, d) (d, e) (e, e)]] at 0x78112c127898>\n\n# %%markdown\n# The \"arg\" and ``nested=True`` versions have the same meanings as with ``cross`` (above).\n\n# %%\na.argpairs()\n# <JaggedArray [[(0, 0) (0, 1) (0, 2) (1, 1) (1, 2) (2, 2)] [] [(0, 0) (0, 1) (1, 1)]] at 0x78112c0d0978>\n\n# %%\na.pairs(nested=True)\n# <JaggedArray [[[(a, a) (a, b) (a, c)] [(b, b) (b, c)] [(c, c)]] [] [[(d, d) (d, e)] [(e, e)]]] at 0x78112c0be2b0>\n\n# %%markdown\n# Just as with ``cross`` (above), this is good to combine with ``unzip`` and maybe a reducer.\n\n# %%\na.pairs().unzip()\n# (<JaggedArray [['a' 'a' 'a' 'b' 'b' 'c'] [] ['d' 'd' 'e']] at 0x78112c0d08d0>,\n#  <JaggedArray [['a' 'b' 'c' 'b' 'c' 'c'] [] ['d' 'e' 'e']] at 0x78112c0d0fd0>)\n\n# %%markdown\n# * ``distincts(nested=False)`` and ``argdistincts(nested=False)``: returns jagged tuples representing the `self-join <https://en.wikipedia.org/wiki/Join_(SQL)#Self-join>`__ removing duplicates and same-object pairs (i.e. a self-join with ``i1 < i2``) for each inner array separately.\n\n# %%\na = awkward.fromiter([[\"a\", \"b\", \"c\"], [], [\"d\", \"e\"]])\na.distincts()\n# <JaggedArray [[(a, b) (a, c) (b, c)] [] [(d, e)]] at 0x78112c127080>\n\n# %%markdown\n# The \"arg\" and ``nested=True`` versions have the same meanings as with ``cross`` (above).\n\n# %%\na.argdistincts()\n# <JaggedArray [[(0, 1) (0, 2) (1, 2)] [] [(0, 1)]] at 0x78112c0d04e0>\n\n# %%\na.distincts(nested=True)\n# <JaggedArray [[[(a, b) (a, c)] [(b, c)]] [] [[(d, e)]]] at 0x78112c0d0a58>\n\n# %%markdown\n# Just as with ``cross`` (above), this is good to combine with ``unzip`` and maybe a reducer.\n\n# %%\na.distincts().unzip()\n# (<JaggedArray [['a' 'a' 'b'] [] ['d']] at 0x78112c11e908>,\n#  <JaggedArray [['b' 'c' 'c'] [] ['e']] at 0x78112c11e518>)\n\n# %%markdown\n# * ``choose(n)`` and ``argchoose(n)``: returns jagged tuples for distinct combinations of ``n`` elements from every inner array separately. ``array.choose(2)`` is the same as ``array.distincts()`` apart from order.\n\n# %%\na = awkward.fromiter([[\"a\", \"b\", \"c\"], [], [\"d\", \"e\"], [\"f\", \"g\", \"h\", \"i\", \"j\"]])\na\n# <JaggedArray [['a' 'b' 'c'] [] ['d' 'e'] ['f' 'g' 'h' 'i' 'j']] at 0x78112c0d0400>\n\n# %%\na.choose(2)\n# <JaggedArray [[(a, b) (a, c) (b, c)] [] [(d, e)] [(f, g) (f, h) (g, h) ... (g, j) (h, j) (i, j)]] at 0x78112c11e0f0>\n\n# %%\na.choose(3)\n# <JaggedArray [[(a, b, c)] [] [] [(f, g, h) (f, g, i) (f, h, i) ... (f, i, j) (g, i, j) (h, i, j)]] at 0x78114c6e46a0>\n\n# %%\na.choose(4)\n# <JaggedArray [[] [] [] [(f, g, h, i) (f, g, h, j) (f, g, i, j) (f, h, i, j) (g, h, i, j)]] at 0x78112c0d0cc0>\n\n# %%markdown\n# The \"arg\" version has the same meaning as ``cross`` (above), but there is no ``nested=True`` because of the order.\n\n# %%\na.argchoose(2)\n# <JaggedArray [[(0, 1) (0, 2) (1, 2)] [] [(0, 1)] [(0, 1) (0, 2) (1, 2) ... (1, 4) (2, 4) (3, 4)]] at 0x78112c11e2b0>\n\n# %%markdown\n# Just as with ``cross`` (above), this is good to combine with ``unzip`` and maybe a reducer.\n\n# %%\na.choose(2).unzip()\n# (<JaggedArray [['a' 'a' 'b'] [] ['d'] ['f' 'f' 'g' ... 'g' 'h' 'i']] at 0x78112c11e5c0>,\n#  <JaggedArray [['b' 'c' 'c'] [] ['e'] ['g' 'h' 'h' ... 'j' 'j' 'j']] at 0x78112c0f7ac8>)\n\n# %%\na.choose(3).unzip()\n# (<JaggedArray [['a'] [] [] ['f' 'f' 'f' ... 'f' 'g' 'h']] at 0x78112c0dc5f8>,\n#  <JaggedArray [['b'] [] [] ['g' 'g' 'h' ... 'i' 'i' 'i']] at 0x78112c0dc3c8>,\n#  <JaggedArray [['c'] [] [] ['h' 'i' 'i' ... 'j' 'j' 'j']] at 0x78112c0dc6d8>)\n\n# %%\na.choose(4).unzip()\n# (<JaggedArray [[] [] [] ['f' 'f' 'f' 'f' 'g']] at 0x78112c0d0eb8>,\n#  <JaggedArray [[] [] [] ['g' 'g' 'g' 'h' 'h']] at 0x78112c11e550>,\n#  <JaggedArray [[] [] [] ['h' 'h' 'i' 'i' 'i']] at 0x78112c11e2e8>,\n#  <JaggedArray [[] [] [] ['i' 'j' 'j' 'j' 'j']] at 0x78112c11e4a8>)\n\n# %%markdown\n# * ``JaggedArray.zip(columns...)``: combines jagged arrays with the same structure into a single jagged array. The columns may be unnamed (resulting in a jagged array of tuples) or named with keyword arguments or dict keys (resulting in a jagged array of a table with named columns).\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\nb = awkward.fromiter([[100, 200, 300], [], [400, 500]])\nawkward.JaggedArray.zip(a, b)\n# <JaggedArray [[(1.1, 100) (2.2, 200) (3.3, 300)] [] [(4.4, 400) (5.5, 500)]] at 0x78112c0f71d0>\n\n# %%\nawkward.JaggedArray.zip(x=a, y=b).tolist()\n# [[{'x': 1.1, 'y': 100}, {'x': 2.2, 'y': 200}, {'x': 3.3, 'y': 300}],\n#  [],\n#  [{'x': 4.4, 'y': 400}, {'x': 5.5, 'y': 500}]]\n\n# %%\nawkward.JaggedArray.zip({\"x\": a, \"y\": b}).tolist()\n# [[{'x': 1.1, 'y': 100}, {'x': 2.2, 'y': 200}, {'x': 3.3, 'y': 300}],\n#  [],\n#  [{'x': 4.4, 'y': 400}, {'x': 5.5, 'y': 500}]]\n\n# %%markdown\n# Not all of the arguments need to be jagged; those that aren't will be broadcasted to the right shape.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\nb = awkward.fromiter([100, 200, 300])\nawkward.JaggedArray.zip(a, b)\n# <JaggedArray [[(1.1, 100) (2.2, 100) (3.3, 100)] [] [(4.4, 300) (5.5, 300)]] at 0x78112c0f7c18>\n\n# %%\nawkward.JaggedArray.zip(a, 1000)\n# <JaggedArray [[(1.1, 1000) (2.2, 1000) (3.3, 1000)] [] [(4.4, 1000) (5.5, 1000)]] at 0x78112c0f72e8>\n\n# %%markdown\n# ## Properties and methods for tabular columns\n#\n# All awkward arrays have these methods, but they provide information about the first nested ``Table`` within a structure. If, for instance, the ``Table`` is within some structure that doesn't affect high-level type (e.g. ``IndexedArray``, ``ChunkedArray``, ``VirtualArray``), then the methods are passed through to the ``Table``. If it's nested within something that does change type, but can meaningfully pass on the call, such as ``MaskedArray``, then that's what they do.\n#\n# * ``columns``: the names of the columns at the first tabular level of depth.\n\n# %%\na = awkward.fromiter([{\"x\": 1, \"y\": 1.1, \"z\": \"one\"}, {\"x\": 2, \"y\": 2.2, \"z\": \"two\"}, {\"x\": 3, \"y\": 3.3, \"z\": \"three\"}])\na.tolist()\n# [{'x': 1, 'y': 1.1, 'z': 'one'},\n#  {'x': 2, 'y': 2.2, 'z': 'two'},\n#  {'x': 3, 'y': 3.3, 'z': 'three'}]\n\n# %%\na.columns\n# ['x', 'y', 'z']\n\n# %%\na = awkward.Table(x=[1, 2, 3],\n                  y=[1.1, 2.2, 3.3],\n                  z=awkward.Table(a=[4, 5, 6], b=[4.4, 5.5, 6.6]))\na.tolist()\n# [{'x': 1, 'y': 1.1, 'z': {'a': 4, 'b': 4.4}},\n#  {'x': 2, 'y': 2.2, 'z': {'a': 5, 'b': 5.5}},\n#  {'x': 3, 'y': 3.3, 'z': {'a': 6, 'b': 6.6}}]\n\n# %%\na.columns\n# ['x', 'y', 'z']\n\n# %%\na[\"z\"].columns\n# ['a', 'b']\n\n# %%\na.z.columns\n# ['a', 'b']\n\n# %%markdown\n# * ``unzip()``: returns a tuple of projections through each of the columns (in the same order as the ``columns`` property).\n\n# %%\na = awkward.fromiter([{\"x\": 1, \"y\": 1.1, \"z\": \"one\"}, {\"x\": 2, \"y\": 2.2, \"z\": \"two\"}, {\"x\": 3, \"y\": 3.3, \"z\": \"three\"}])\na.unzip()\n# (array([1, 2, 3]),\n#  array([1.1, 2.2, 3.3]),\n#  <StringArray ['one' 'two' 'three'] at 0x78112c0d02b0>)\n\n# %%markdown\n# The ``unzip`` method is the opposite of the ``Table`` constructor,\n\n# %%\na = awkward.Table(x=[1, 2, 3],\n                  y=[1.1, 2.2, 3.3],\n                  z=awkward.fromiter([\"one\", \"two\", \"three\"]))\na.tolist()\n# [{'x': 1, 'y': 1.1, 'z': 'one'},\n#  {'x': 2, 'y': 2.2, 'z': 'two'},\n#  {'x': 3, 'y': 3.3, 'z': 'three'}]\n\n# %%\na.unzip()\n# (array([1, 2, 3]),\n#  array([1.1, 2.2, 3.3]),\n#  <StringArray ['one' 'two' 'three'] at 0x78112c115a20>)\n\n# %%markdown\n# but it is also the opposite of ``JaggedArray.zip``.\n\n# %%\nb = awkward.JaggedArray.zip(x=awkward.fromiter([[1, 2, 3], [], [4, 5]]),\n                            y=awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]]),\n                            z=awkward.fromiter([[\"a\", \"b\", \"c\"], [], [\"d\", \"e\"]]))\nb.tolist()\n# [[{'x': 1, 'y': 1.1, 'z': 'a'},\n#   {'x': 2, 'y': 2.2, 'z': 'b'},\n#   {'x': 3, 'y': 3.3, 'z': 'c'}],\n#  [],\n#  [{'x': 4, 'y': 4.4, 'z': 'd'}, {'x': 5, 'y': 5.5, 'z': 'e'}]]\n\n# %%\nb.unzip()\n# (<JaggedArray [[1 2 3] [] [4 5]] at 0x78112c14fe10>,\n#  <JaggedArray [[1.1 2.2 3.3] [] [4.4 5.5]] at 0x78112c14f9b0>,\n#  <JaggedArray [['a' 'b' 'c'] [] ['d' 'e']] at 0x78112c14fa90>)\n\n# %%markdown\n# ``JaggedArray.zip`` produces a jagged array of ``Table`` whereas the ``Table`` constructor produces just a ``Table``, and these are distinct things, though they can both be inverted by the same function because row indexes and column indexes commute:\n\n# %%\nb[0][\"y\"]\n# array([1.1, 2.2, 3.3])\n\n# %%\nb[\"y\"][0]\n# array([1.1, 2.2, 3.3])\n\n# %%markdown\n# So ``unzip`` turns a flat ``Table`` into a tuple of flat arrays (opposite of the ``Table`` constructor) and it turns a jagged ``Table`` into a tuple of jagged arrays (opposite of ``JaggedArray.zip``).\n#\n# * ``istuple``: an array of tuples is a special kind of ``Table``, one whose ``rowname`` is ``\"tuple\"`` and columns are ``\"0\"``, ``\"1\"``, ``\"2\"``, etc. If these conditions are met, ``istuple`` is ``True``; otherwise, ``False``.\n\n# %%\na = awkward.Table(x=[1, 2, 3],\n                  y=[1.1, 2.2, 3.3],\n                  z=awkward.fromiter([\"one\", \"two\", \"three\"]))\na.tolist()\n# [{'x': 1, 'y': 1.1, 'z': 'one'},\n#  {'x': 2, 'y': 2.2, 'z': 'two'},\n#  {'x': 3, 'y': 3.3, 'z': 'three'}]\n\n# %%\na.istuple\n# False\n\n# %%\na = awkward.Table([1, 2, 3],\n                  [1.1, 2.2, 3.3],\n                  awkward.fromiter([\"one\", \"two\", \"three\"]))\na.tolist()\n# [(1, 1.1, 'one'), (2, 2.2, 'two'), (3, 3.3, 'three')]\n\n# %%\na.istuple\n# True\n\n# %%markdown\n# Even though the following tuples are inside of a jagged array, the first level of ``Table`` is a tuple, so ``istuple`` is ``True``.\n\n# %%\nb = awkward.JaggedArray.zip(awkward.fromiter([[1, 2, 3], [], [4, 5]]),\n                            awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]]),\n                            awkward.fromiter([[\"a\", \"b\", \"c\"], [], [\"d\", \"e\"]]))\nb\n# <JaggedArray [[(1, 1.1, a) (2, 2.2, b) (3, 3.3, c)] [] [(4, 4.4, d) (5, 5.5, e)]] at 0x78112c0d0e48>\n\n# %%\nb.istuple\n# True\n\n# %%markdown\n# * ``i0`` through ``i9``: one of the two conditions for a ``Table`` to be a ``tuple`` is that columns are named ``\"0\"``, ``\"1\"``, ``\"2\"``, etc. Columns like that could be selected with ``[\"0\"]`` at the risk of being misread as ``[0]``, and they could not be selected with attribute dot-access because pure numbers are not valid Python attributes. However, ``i0`` through ``i9`` are provided as shortcuts (overriding any columns with these exact names) for the first 10 tuple slots.\n\n# %%\na = awkward.Table([1, 2, 3],\n                  [1.1, 2.2, 3.3],\n                  awkward.fromiter([\"one\", \"two\", \"three\"]))\na.tolist()\n# [(1, 1.1, 'one'), (2, 2.2, 'two'), (3, 3.3, 'three')]\n\n# %%\na.i0\n# array([1, 2, 3])\n\n# %%\na.i1\n# array([1.1, 2.2, 3.3])\n\n# %%\na.i2\n# <StringArray ['one' 'two' 'three'] at 0x78112c14fe80>\n\n# %%markdown\n# * ``flattentuple()``: calling ``cross`` repeatedly can result in tuples nested within tuples; this flattens them at all levels, turning all ``(i, (j, k))`` into ``(i, j, k)``. Whereas ``array.flatten()`` removes one level of structure from the rows (losing information), ``array.flattentuple()`` removes all levels of structure from the columns (renaming them, but not losing information).\n\n# %%\na = awkward.Table([1, 2, 3], [1, 2, 3], awkward.Table(awkward.Table([1, 2, 3], [1, 2, 3]), [1, 2, 3]))\na.tolist()\n# [(1, 1, ((1, 1), 1)), (2, 2, ((2, 2), 2)), (3, 3, ((3, 3), 3))]\n\n# %%\na.flattentuple().tolist()\n# [(1, 1, 1, 1, 1), (2, 2, 2, 2, 2), (3, 3, 3, 3, 3)]\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6, 7.7, 8.8, 9.9]])\nb = awkward.fromiter([[100, 200], [300], [400, 500, 600], [700]])\nc = awkward.fromiter([[\"a\"], [\"b\", \"c\"], [\"d\"], [\"e\", \"f\"]])\n\n# %%markdown\n# The ``cross`` method internally calls ``flattentuples()`` if it detects that one of its arguments is the result of a ``cross``.\n\n# %%\na.cross(b).cross(c).tolist()\n# [[(1.1, 100, 'a'),\n#   (1.1, 200, 'a'),\n#   (2.2, 100, 'a'),\n#   (2.2, 200, 'a'),\n#   (3.3, 100, 'a'),\n#   (3.3, 200, 'a')],\n#  [],\n#  [(4.4, 400, 'd'),\n#   (4.4, 500, 'd'),\n#   (4.4, 600, 'd'),\n#   (5.5, 400, 'd'),\n#   (5.5, 500, 'd'),\n#   (5.5, 600, 'd')],\n#  [(6.6, 700, 'e'),\n#   (6.6, 700, 'f'),\n#   (7.7, 700, 'e'),\n#   (7.7, 700, 'f'),\n#   (8.8, 700, 'e'),\n#   (8.8, 700, 'f'),\n#   (9.9, 700, 'e'),\n#   (9.9, 700, 'f')]]\n\n# %%markdown\n# ## Properties and methods for missing values\n#\n# All awkward arrays have these methods, but they provide information about the first nested ``MaskedArray`` within a structure. If, for instance, the ``MaskedArray`` is within some structure that doesn't affect high-level type (e.g. ``IndexedArray``, ``ChunkedArray``, ``VirtualArray``), then the methods are passed through to the ``MaskedArray``. If it's nested within something that does change type, but can meaningfully pass on the call, such as ``JaggedArray``, then that's what they do.\n#\n# * ``boolmask(maskedwhen=None)``: returns a Numpy array of booleans indicating which elements are missing (\"masked\") and which are not. If ``maskedwhen=True``, a ``True`` value in the Numpy array means missing/masked; if ``maskedwhen=False``, a ``False`` value in the Numpy array means missing/masked. If no value is passed (or ``None``), the ``MaskedArray``'s own ``maskedwhen`` property is used (which is by default ``True``). Non-``MaskedArrays`` are assumed to have a ``maskedwhen`` of ``True`` (the default).\n\n# %%\na = awkward.fromiter([1, 2, None, 3, 4, None, None, 5])\na.boolmask()\n# array([False, False,  True, False, False,  True,  True, False])\n\n# %%\na.boolmask(maskedwhen=False)\n# array([ True,  True, False,  True,  True, False, False,  True])\n\n# %%markdown\n# ``MaskedArrays`` inside of ``JaggedArrays`` or ``Tables`` are hidden.\n\n# %%\na = awkward.fromiter([[1.1, None, 2.2], [], [3.3, 4.4, None, 5.5]])\na.boolmask()\n# array([False, False, False])\n\n# %%\na.flatten().boolmask()\n# array([False,  True, False, False, False,  True, False])\n\n# %%\na = awkward.fromiter([{\"x\": 1, \"y\": 1.1}, {\"x\": None, \"y\": 2.2}, {\"x\": None, \"y\": 3.3}, {\"x\": 4, \"y\": None}])\na.boolmask()\n# array([False, False, False, False])\n\n# %%\na.x.boolmask()\n# array([False,  True,  True, False])\n\n# %%\na.y.boolmask()\n# array([False, False, False,  True])\n\n# %%markdown\n# * ``ismasked`` and ``isunmasked``: shortcut for ``boolmask(maskedwhen=True)`` and ``boolmask(maskedwhen=False)`` as a property, which is more appropriate for analysis.\n\n# %%\na = awkward.fromiter([1, 2, None, 3, 4, None, None, 5])\na.ismasked\n# array([False, False,  True, False, False,  True,  True, False])\n\n# %%\na.isunmasked\n# array([ True,  True, False,  True,  True, False, False,  True])\n\n# %%markdown\n# * ``fillna(value)``: turn a ``MaskedArray`` into a non-``MaskedArray`` by replacing ``None`` with ``value``. Applies to the outermost ``MaskedArray``, but it passes through ``JaggedArrays`` and into all ``Table`` columns.\n\n# %%\na = awkward.fromiter([1, 2, None, 3, 4, None, None, 5])\na.fillna(999)\n# array([  1,   2, 999,   3,   4, 999, 999,   5])\n\n# %%\na = awkward.fromiter([[1.1, None, 2.2], [], [3.3, 4.4, None, 5.5]])\na.fillna(999)\n# <JaggedArray [[1.1 999.0 2.2] [] [3.3 4.4 999.0 5.5]] at 0x78112c0859b0>\n\n# %%\na = awkward.fromiter([{\"x\": 1, \"y\": 1.1}, {\"x\": None, \"y\": 2.2}, {\"x\": None, \"y\": 3.3}, {\"x\": 4, \"y\": None}])\na.fillna(999).tolist()\n# [{'x': 1, 'y': 1.1},\n#  {'x': 999, 'y': 2.2},\n#  {'x': 999, 'y': 3.3},\n#  {'x': 4, 'y': 999.0}]\n\n# %%markdown\n# ## Functions for structure manipulation\n#\n# Only one structure-manipulation function (for now) is defined at top-level in awkward-array: ``awkward.concatenate``.\n#\n# * ``awkward.concatenate(arrays, axis=0)``: concatenate two or more ``arrays``. If ``axis=0``, the arrays are concatenated lengthwise (the resulting length is the sum of the lengths of each of the ``arrays``). If ``axis=1``, each inner array is concatenated: the input ``arrays`` must all be jagged with the same outer array length. (Values of ``axis`` greater than ``1`` are not yet supported.)\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\nb = awkward.fromiter([[100, 200], [300], [400, 500, 600]])\nawkward.concatenate([a, b])\n# <JaggedArray [[1.1 2.2 3.3] [] [4.4 5.5] [100.0 200.0] [300.0] [400.0 500.0 600.0]] at 0x78112c122c88>\n\n# %%\nawkward.concatenate([a, b], axis=1)\n# <JaggedArray [[1.1 2.2 3.3 100.0 200.0] [300.0] [4.4 5.5 400.0 500.0 600.0]] at 0x78112c425978>\n\n# %%\na = awkward.fromiter([{\"x\": 1, \"y\": 1.1}, {\"x\": 2, \"y\": 2.2}, {\"x\": 3, \"y\": 3.3}])\nb = awkward.fromiter([{\"x\": 4, \"y\": 4.4}, {\"x\": 5, \"y\": 5.5}])\nawkward.concatenate([a, b]).tolist()\n# [{'x': 1, 'y': 1.1},\n#  {'x': 2, 'y': 2.2},\n#  {'x': 3, 'y': 3.3},\n#  {'x': 4, 'y': 4.4},\n#  {'x': 5, 'y': 5.5}]\n\n# %%markdown\n# If the arrays have different types, their concatenation is a ``UnionArray``.\n\n# %%\na = awkward.fromiter([{\"x\": 1, \"y\": 1.1}, {\"x\": 2, \"y\": 2.2}, {\"x\": 3, \"y\": 3.3}])\nb = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\nawkward.concatenate([a, b]).tolist()\n# [{'x': 1, 'y': 1.1},\n#  {'x': 2, 'y': 2.2},\n#  {'x': 3, 'y': 3.3},\n#  [1.1, 2.2, 3.3],\n#  [],\n#  [4.4, 5.5]]\n\n# %%\na = awkward.fromiter([1, None, 2])\nb = awkward.fromiter([None, 3, None])\nawkward.concatenate([a, b])\n# <MaskedArray [1 None 2 None 3 None] at 0x78112c085da0>\n\n# %%\nimport awkward, numpy\na = awkward.fromiter([\"one\", \"two\", \"three\"])\nb = awkward.fromiter([\"four\", \"five\", \"six\"])\nawkward.concatenate([a, b])\n# <StringArray ['one' 'two' 'three' 'four' 'five' 'six'] at 0x78112c14f7f0>\n\n# %%\nawkward.concatenate([a, b], axis=1)\n# <StringArray ['onefour' 'twofive' 'threesix'] at 0x78112c115518>\n\n# %%markdown\n# # Functions for input/output and conversion\n#\n# Most of the functions defined at the top-level of the library are conversion functions.\n#\n# * ``awkward.fromiter(iterable, awkwardlib=None, dictencoding=False, maskedwhen=True)``: convert Python or JSON data into awkward arrays. Not a fast function: it necessarily involves a Python for loop. The ``awkwardlib`` determines which awkward module to use to make arrays (``awkward`` is the default, but ``awkward.numba`` and ``awkward.cpp`` are alternatives). If ``dictencoding`` is ``True``, bytes and strings will be \"dictionary-encoded\" in Arrow/Parquet terms—this is an ``IndexedArray`` in awkward. The ``maskedwhen`` parameter determines whether ``MaskedArrays`` have a mask that is ``True`` when data are missing or ``False`` when data are missing.\n\n# %%\n# We have been using this function all along, but why not another example?\ncomplicated = awkward.fromiter([[1.1, 2.2, None, 3.3, None],\n                                [4.4, [5.5]],\n                                [{\"x\": 6, \"y\": {\"z\": 7}}, None, {\"x\": 8, \"y\": {\"z\": 9}}]\n                               ])\ncomplicated\n# <JaggedArray [[1.1 2.2 None 3.3 None] [4.4 [5.5]] [<Row 0> None <Row 1>]] at 0x78112c0ef438>\n\n# %%markdown\n# The fact that this nested, row-wise data have been converted into columnar arrays can be seen by inspecting its ``layout``.\n\n# %%\ncomplicated.layout\n#  layout\n# [           ()] JaggedArray(starts=layout[0], stops=layout[1], content=layout[2])\n# [            0]   ndarray(shape=3, dtype=dtype('int64'))\n# [            1]   ndarray(shape=3, dtype=dtype('int64'))\n# [            2]   IndexedMaskedArray(mask=layout[2, 0], content=layout[2, 1], maskedwhen=-1)\n# [         2, 0]     ndarray(shape=10, dtype=dtype('int64'))\n# [         2, 1]     UnionArray(tags=layout[2, 1, 0], index=layout[2, 1, 1], contents=[layout[2, 1, 2], layout[2, 1, 3], layout[2, 1, 4]])\n# [      2, 1, 0]       ndarray(shape=7, dtype=dtype('uint8'))\n# [      2, 1, 1]       ndarray(shape=7, dtype=dtype('int64'))\n# [      2, 1, 2]       ndarray(shape=4, dtype=dtype('float64'))\n# [      2, 1, 3]       JaggedArray(starts=layout[2, 1, 3, 0], stops=layout[2, 1, 3, 1], content=layout[2, 1, 3, 2])\n# [   2, 1, 3, 0]         ndarray(shape=1, dtype=dtype('int64'))\n# [   2, 1, 3, 1]         ndarray(shape=1, dtype=dtype('int64'))\n# [   2, 1, 3, 2]         ndarray(shape=1, dtype=dtype('float64'))\n# [      2, 1, 4]       Table(x=layout[2, 1, 4, 0], y=layout[2, 1, 4, 1])\n# [   2, 1, 4, 0]         ndarray(shape=2, dtype=dtype('int64'))\n# [   2, 1, 4, 1]         Table(z=layout[2, 1, 4, 1, 0])\n# [2, 1, 4, 1, 0]           ndarray(shape=2, dtype=dtype('int64'))\n\n# %%\nfor index, node in complicated.layout.items():\n    if node.cls == numpy.ndarray:\n        print(\"[{0:>13s}] {1}\".format(\", \".join(repr(i) for i in index), repr(node.array)))\n# [            0] array([0, 5, 7])\n# [            1] array([ 5,  7, 10])\n# [         2, 0] array([ 0,  1, -1,  2, -1,  3,  4,  5, -1,  6])\n# [      2, 1, 0] array([0, 0, 0, 0, 1, 2, 2], dtype=uint8)\n# [      2, 1, 1] array([0, 1, 2, 3, 0, 0, 1])\n# [      2, 1, 2] array([1.1, 2.2, 3.3, 4.4])\n# [   2, 1, 3, 0] array([0])\n# [   2, 1, 3, 1] array([1])\n# [   2, 1, 3, 2] array([5.5])\n# [   2, 1, 4, 0] array([6, 8])\n# [2, 1, 4, 1, 0] array([7, 9])\n\n# %%markdown\n# The number of arrays in this object scales with the complexity of its data type, but not with the size of the dataset. If it were as complicated as it is now but billions of elements long, it would still contain 11 Numpy arrays, and operations on it would scale as Numpy scales. However, converting a billion Python objects to these 11 arrays would be a large up-front cost.\n#\n# More detail on the row-wise to columnar conversion process is given in `docs/fromiter.adoc <https://github.com/scikit-hep/awkward-array/blob/master/docs/fromiter.adoc>`__.\n\n# %%markdown\n# * ``load(file, awkwardlib=None, whitelist=awkward.persist.whitelist, cache=None, schemasuffix=\".json\")``: loads data from an \"awkd\" (special ZIP) file. This function is like ``numpy.load``, but for awkward arrays. If the file contains a single object, that object will be read immediately; if it has a collection of named arrays, it will return a loader that loads those arrays on demand. The ``awkwardlib`` determines the module to use to define arrays, the ``whitelist`` is where you can provide a list of functions that may be called in this process, ``cache`` is a global cache object assigned to ``VirtualArrays``, and ``schemasuffix`` determines the file name pattern to look for objects inside the ZIP file.\n#\n# * ``save(file, array, name=None, mode=\"a\", compression=awkward.persist.compression, delimiter=\"-\", suffix=\".raw\", schemasuffix=\".json\")``: saves data to an \"awkd\" (special ZIP) file. This function is like ``numpy.savez`` and is the reverse of ``load`` (above). The ``array`` may be a single object or a dict of named arrays, the ``name`` is a name to use inside the file, ``mode=\"a\"`` means create or append to an existing file, refusing to overwrite data while ``mode=\"w\"`` overwrites data, ``compression`` is a compression policy (set of rules determining which arrays to compress and how), and the rest of the arguments determine file names within the ZIP: ``delimiter`` between name components, ``suffix`` for array data, and ``schemasuffix`` for the schemas that tell ``load`` how to find all other data.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\nb = awkward.fromiter([[1.1, 2.2, None, 3.3, None],\n                      [4.4, [5.5]],\n                      [{\"x\": 6, \"y\": {\"z\": 7}}, None, {\"x\": 8, \"y\": {\"z\": 9}}]\n                     ])\n\n# %%\nawkward.save(\"single.awkd\", a, mode=\"w\")\n\n# %%\nawkward.load(\"single.awkd\")\n# <JaggedArray [[1.1 2.2 3.3] [] [4.4 5.5]] at 0x78112c14ff98>\n\n# %%\nawkward.save(\"multi.awkd\", {\"a\": a, \"b\": b}, mode=\"w\")\n\n# %%\nmulti = awkward.load(\"multi.awkd\")\n\n# %%\nmulti[\"a\"]\n# <JaggedArray [[1.1 2.2 3.3] [] [4.4 5.5]] at 0x78112c0906d8>\n\n# %%\nmulti[\"b\"]\n# <JaggedArray [[1.1 2.2 None 3.3 None] [4.4 [5.5]] [<Row 0> None <Row 1>]] at 0x78112c0906a0>\n\n# %%markdown\n# Only ``save`` has a ``compression`` parameter because only the writing process gets to decide how arrays are compressed. We don't use ZIP's built-in compression, but use Python compression functions and encode the choice in the metadata. If ``compression=True``, all arrays will be compressed with zlib; if ``compression=False``, ``None``, or ``[]``, none will. In general, ``compression`` is a list of rules; the first rule that is satisfied by a given array uses the specified compress/decompress pair of functions. Here's the default policy:\n\n# %%\nawkward.persist.compression\n# [{'minsize': 8192,\n#   'types': [numpy.bool_, bool, numpy.integer],\n#   'contexts': '*',\n#   'pair': (<function zlib.compress(data, /, level=-1)>,\n#    ('zlib', 'decompress'))}]\n\n# %%markdown\n# The default policy has only one rule. If any array has a minimum size (``minsize``) of 8 kB (``8192`` bytes), a numeric type (``array.dtype.type``) that is a subclass of ``numpy.bool_``, ``bool``, or ``numpy.integer``, and is in any awkward-array context (``JaggedArray.starts``, ``MaskedArray.mask``, etc.), then it will be compressed with ``zip.compress`` and decompressed with ``('zlib', 'decompress')``. The compression function is given as an object—the Python function that will be called to transform byte strings into compressed byte strings—but the decompression function is given as a location in Python's namespace: a tuple of nested objects, the first of which is a fully qualified module name (submodules separated by dots). This is because only the *location* of the decompression function needs to be written to the file.\n#\n# The saved awkward array consists of a collection of byte strings for Numpy arrays (2 for object ``a`` and 11 for object ``b``, above) and JSON-formatted metadata that reconstructs the nested hierarchy of awkward classes around those Numpy arrays. This metadata includes information such as which byte strings should be decompressed and how, but also which awkward constructors to call to fit everything together. As such, the JSON metadata is code, a limited language without looping or function definitions (i.e. not Turing complete) but with the ability to call any Python function.\n#\n# Using a mini-language as metadata gives us great capacity for backward and forward compatibility (new or old ways of encoding things are simply calling different functions), but it does raise the danger of malicious array files calling unwanted Python functions. For this reason, ``load`` refuses to call any functions not specified in a ``whitelist``. The default whitelist consists of functions known to be safe:\n\n# %%\nawkward.persist.whitelist\n# [['numpy', 'frombuffer'],\n#  ['zlib', 'decompress'],\n#  ['lzma', 'decompress'],\n#  ['backports.lzma', 'decompress'],\n#  ['lz4.block', 'decompress'],\n#  ['awkward', '*Array'],\n#  ['awkward', 'Table'],\n#  ['awkward', 'numpy', 'frombuffer'],\n#  ['awkward.util', 'frombuffer'],\n#  ['awkward.persist'],\n#  ['awkward.arrow', '_ParquetFile', 'fromjson'],\n#  ['uproot_methods.classes.*'],\n#  ['uproot_methods.profiles.*'],\n#  ['uproot.tree', '_LazyFiles'],\n#  ['uproot.tree', '_LazyTree'],\n#  ['uproot.tree', '_LazyBranch']]\n\n# %%markdown\n# The format of each item in the whitelist is a list of nested objects, the first of which being a fully qualified module name (submodules separated by dots). For instance, in the ``awkward.arrow`` submodule, there is a class named ``_ParquetFile`` and it has a static method ``fromjson`` that is deemed to be safe. Patterns of safe names are can be wildcarded, such as ``['awkward', '*Array']`` and ``['uproot_methods.classes.*']``.\n#\n# You can add your own functions, and forward compatibility (using data made by a new version in an old version of awkward-array) often dictates that you must add a function manually. The error message explains how to do this.\n#\n# The same serialization format is used when you pickle an awkward array or save it in an HDF5 file. More detail on the metadata mini-language is given in `docs/serialization.adoc <https://github.com/scikit-hep/awkward-array/blob/master/docs/serialization.adoc>`__.\n\n# %%markdown\n# * ``hdf5(group, awkwardlib=None, compression=awkward.persist.compression, whitelist=awkward.persist.whitelist, cache=None)``: wrap a ``h5py.Group`` as an awkward-aware group, to save awkward arrays to HDF5 files and to read them back again. The options have the same meaning as ``load`` and ``save``.\n#\n# Unlike \"awkd\" (special ZIP) files, HDF5 files can be written and overwritten like a database, rather than write-once files.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\nb = awkward.fromiter([[1.1, 2.2, None, 3.3, None],\n                      [4.4, [5.5]],\n                      [{\"x\": 6, \"y\": {\"z\": 7}}, None, {\"x\": 8, \"y\": {\"z\": 9}}]\n                     ])\n\n# %%\nimport h5py\nf = h5py.File(\"awkward.hdf5\", \"w\")\nf\n# <HDF5 file \"awkward.hdf5\" (mode r+)>\n\n# %%\ng = awkward.hdf5(f)\ng\n# <awkward.hdf5 '/' (0 members)>\n\n# %%\ng[\"array\"] = a\n\n# %%\ng[\"array\"]\n# <JaggedArray [[1.1 2.2 3.3] [] [4.4 5.5]] at 0x781115141320>\n\n# %%\ndel g[\"array\"]\n\n# %%\ng[\"array\"] = b\n\n# %%\ng[\"array\"]\n# <JaggedArray [[1.1 2.2 None 3.3 None] [4.4 [5.5]] [<Row 0> None <Row 1>]] at 0x7811883b9198>\n\n# %%markdown\n# The HDF5 format does not include columnar representations of arbitrary nested data, as awkward-array does, so what we're actually storing are plain Numpy arrays and the metadata necessary to reconstruct the awkward array.\n\n# %%\n# Reopen file, without wrapping it as awkward.hdf5 this time.\nf = h5py.File(\"awkward.hdf5\", \"r\")\nf\n# <HDF5 file \"awkward.hdf5\" (mode r+)>\n\n# %%\nf[\"array\"]\n# <HDF5 group \"/array\" (9 members)>\n\n# %%\nf[\"array\"].keys()\n# <KeysViewHDF5 ['1', '12', '14', '16', '19', '4', '7', '9', 'schema.json']>\n\n# %%markdown\n# The \"schema.json\" array is the JSON metadata, containing directives like ``{\"call\": [\"awkward\", \"JaggedArray\", \"fromcounts\"]}`` and ``{\"read\": \"1\"}`` meaning the array named ``\"1\"``, etc.\n\n# %%\nimport json\njson.loads(f[\"array\"][\"schema.json\"][:].tostring())\n# {'awkward': '0.12.0rc1',\n#  'schema': {'call': ['awkward', 'JaggedArray', 'fromcounts'],\n#   'args': [{'call': ['awkward', 'numpy', 'frombuffer'],\n#     'args': [{'read': '1'}, {'dtype': 'int64'}, {'json': 3, 'id': 2}],\n#     'id': 1},\n#    {'call': ['awkward', 'IndexedMaskedArray'],\n#     'args': [{'call': ['awkward', 'numpy', 'frombuffer'],\n#       'args': [{'read': '4'}, {'dtype': 'int64'}, {'json': 10, 'id': 5}],\n#       'id': 4},\n#      {'call': ['awkward', 'UnionArray', 'fromtags'],\n#       'args': [{'call': ['awkward', 'numpy', 'frombuffer'],\n#         'args': [{'read': '7'}, {'dtype': 'uint8'}, {'json': 7, 'id': 8}],\n#         'id': 7},\n#        {'list': [{'call': ['awkward', 'numpy', 'frombuffer'],\n#           'args': [{'read': '9'}, {'dtype': 'float64'}, {'json': 4, 'id': 10}],\n#           'id': 9},\n#          {'call': ['awkward', 'JaggedArray', 'fromcounts'],\n#           'args': [{'call': ['awkward', 'numpy', 'frombuffer'],\n#             'args': [{'read': '12'},\n#              {'dtype': 'int64'},\n#              {'json': 1, 'id': 13}],\n#             'id': 12},\n#            {'call': ['awkward', 'numpy', 'frombuffer'],\n#             'args': [{'read': '14'}, {'dtype': 'float64'}, {'ref': 13}],\n#             'id': 14}],\n#           'id': 11},\n#          {'call': ['awkward', 'Table', 'frompairs'],\n#           'args': [{'pairs': [['x',\n#               {'call': ['awkward', 'numpy', 'frombuffer'],\n#                'args': [{'read': '16'},\n#                 {'dtype': 'int64'},\n#                 {'json': 2, 'id': 17}],\n#                'id': 16}],\n#              ['y',\n#               {'call': ['awkward', 'Table', 'frompairs'],\n#                'args': [{'pairs': [['z',\n#                    {'call': ['awkward', 'numpy', 'frombuffer'],\n#                     'args': [{'read': '19'}, {'dtype': 'int64'}, {'ref': 17}],\n#                     'id': 19}]]},\n#                 {'json': 0}],\n#                'id': 18}]]},\n#            {'json': 0}],\n#           'id': 15}]}],\n#       'id': 6},\n#      {'json': -1}],\n#     'id': 3}],\n#   'id': 0},\n#  'prefix': 'array/'}\n\n# %%markdown\n# Without awkward-array, these objects can't be meaningfully read back from the HDF5 file.\n\n# %%markdown\n# * ``awkward.fromarrow(arrow, awkwardlib=None)``: convert an `Apache Arrow <https://arrow.apache.org>`__ formatted buffer to an awkward array (zero-copy). The ``awkwardlib`` parameter has the same meaning as above.\n#\n# * ``awkward.toarrow(array)``: convert an awkward array to an Apache Arrow buffer, if possible (involving a data copy, but no Python loops).\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\nb = awkward.fromiter([[1.1, 2.2, None, 3.3, None],\n                      [4.4, [5.5]],\n                      [{\"x\": 6, \"y\": {\"z\": 7}}, None, {\"x\": 8, \"y\": {\"z\": 9}}]\n                     ])\n\n# %%\nawkward.toarrow(a)\n# <pyarrow.lib.ListArray object at 0x78110846b1a8>\n# [\n#   [\n#     1.1,\n#     2.2,\n#     3.3\n#   ],\n#   [],\n#   [\n#     4.4,\n#     5.5\n#   ]\n# ]\n\n# %%\nawkward.fromarrow(awkward.toarrow(a))\n# <JaggedArray [[1.1 2.2 3.3] [] [4.4 5.5]] at 0x78110846d550>\n\n# %%\nawkward.toarrow(b)\n# <pyarrow.lib.ListArray object at 0x78110846b6d0>\n# [\n#   -- is_valid: all not null\n#   -- type_ids:     [\n#       0,\n#       0,\n#       2,\n#       0,\n#       2\n#     ]\n#   -- value_offsets:     [\n#       0,\n#       1,\n#       1,\n#       2,\n#       1\n#     ]\n#   -- child 0 type: double\n#     [\n#       1.1,\n#       2.2,\n#       3.3,\n#       4.4\n#     ]\n#   -- child 1 type: list<item: double>\n#     [\n#       [\n#         5.5\n#       ]\n#     ]\n#   -- child 2 type: struct<x: int64, y: struct<z: int64>>\n#     -- is_valid: all not null\n#     -- child 0 type: int64\n#       [\n#         6,\n#         8\n#       ]\n#     -- child 1 type: struct<z: int64>\n#       -- is_valid: all not null\n#       -- child 0 type: int64\n#         [\n#           7,\n#           9\n#         ],\n#   -- is_valid: all not null\n#   -- type_ids:     [\n#       0,\n#       1\n#     ]\n#   -- value_offsets:     [\n#       3,\n#       0\n#     ]\n#   -- child 0 type: double\n#     [\n#       1.1,\n#       2.2,\n#       3.3,\n#       4.4\n#     ]\n#   -- child 1 type: list<item: double>\n#     [\n#       [\n#         5.5\n#       ]\n#     ]\n#   -- child 2 type: struct<x: int64, y: struct<z: int64>>\n#     -- is_valid: all not null\n#     -- child 0 type: int64\n#       [\n#         6,\n#         8\n#       ]\n#     -- child 1 type: struct<z: int64>\n#       -- is_valid: all not null\n#       -- child 0 type: int64\n#         [\n#           7,\n#           9\n#         ],\n#   -- is_valid: all not null\n#   -- type_ids:     [\n#       2,\n#       2,\n#       2\n#     ]\n#   -- value_offsets:     [\n#       0,\n#       1,\n#       1\n#     ]\n#   -- child 0 type: double\n#     [\n#       1.1,\n#       2.2,\n#       3.3,\n#       4.4\n#     ]\n#   -- child 1 type: list<item: double>\n#     [\n#       [\n#         5.5\n#       ]\n#     ]\n#   -- child 2 type: struct<x: int64, y: struct<z: int64>>\n#     -- is_valid: all not null\n#     -- child 0 type: int64\n#       [\n#         6,\n#         8\n#       ]\n#     -- child 1 type: struct<z: int64>\n#       -- is_valid: all not null\n#       -- child 0 type: int64\n#         [\n#           7,\n#           9\n#         ]\n# ]\n\n# %%\nawkward.fromarrow(awkward.toarrow(b))\n# <JaggedArray [[1.1 2.2 <Row 1> 3.3 <Row 1>] [4.4 [5.5]] [<Row 0> <Row 1> <Row 1>]] at 0x78110846de48>\n\n# %%markdown\n# Unlike HDF5, Arrow is capable of columnar jagged arrays, nullable values, nested structures, etc. If you save an awkward array in Arrow format, someone else can read it without the awkward-array library. There are a few awkward array classes that don't have an Arrow equivalent, though. Below is a list of all translations.\n#\n# * Numpy array → Arrow `BooleanArray <https://arrow.apache.org/docs/python/generated/pyarrow.BooleanArray.html>`__, `IntegerArray <https://arrow.apache.org/docs/python/generated/pyarrow.IntegerArray.html>`__, or `FloatingPointArray <https://arrow.apache.org/docs/python/generated/pyarrow.FloatingPointArray.html>`__.\n# * ``JaggedArray`` → Arrow `ListArray <https://arrow.apache.org/docs/python/generated/pyarrow.ListArray.html>`__.\n# * ``StringArray`` → Arrow `StringArray <https://arrow.apache.org/docs/python/generated/pyarrow.StringArray.html>`__.\n# * ``Table`` → Arrow `Table <https://arrow.apache.org/docs/python/generated/pyarrow.Table.html>`__ at top-level, but an Arrow `StructArray <https://arrow.apache.org/docs/python/generated/pyarrow.StructArray.html>`__ if nested.\n# * ``MaskedArray`` → missing data mask (nullability in Arrow is an array attribute, rather than an array wrapper).\n# * ``IndexedMaskedArray`` → unfolded into a simple mask before the Arrow translation.\n# * ``IndexedArray`` → Arrow `DictionaryArray <https://arrow.apache.org/docs/python/generated/pyarrow.DictionaryArray.html>`__.\n# * ``SparseArray`` → converted to a dense array before the Arrow translation.\n# * ``ObjectArray`` → Pythonic interpretation is discarded before the Arrow translation.\n# * ``UnionArray`` → Arrow dense `UnionArray <https://arrow.apache.org/docs/python/generated/pyarrow.UnionArray.html>`__ if possible, sparse UnionArray if necessary.\n# * ``ChunkedArray`` (including ``AppendableArray``) → Arrow `RecordBatches <https://arrow.apache.org/docs/python/generated/pyarrow.RecordBatch.html>`__, but only at top-level: nested ``ChunkedArrays`` cannot be converted.\n# * ``VirtualArray`` → array gets materialized before the Arrow translation (i.e. the lazy-loading is not preserved).\n\n# %%markdown\n# Since Arrow is an in-memory format, both ``toarrow`` and ``fromarrow`` are side-effect-free functions with a return value. Functions that write to files have a side-effect (the state of your disk changing) and no return value. Once you've made your Arrow buffer, you have to figure out what to do with it. (You may want to `write it to a stream <https://arrow.apache.org/docs/python/ipc.html>`__ for interprocess communication.)\n\n# %%markdown\n# * ``awkward.fromparquet(where, awkwardlib=None)``: reads from a Parquet file (at filename/URI ``where``) into an awkward array, through pyarrow. The ``awkwardlib`` parameter has the same meaning as above.\n#\n# * ``awkward.toparquet(where, array, schema=None)``: writes an awkward array to a Parquet file (at filename/URI ``where``), through pyarrow. The Parquet ``schema`` may be inferred from the awkward array or explicitly specified.\n#\n# Like Arrow and unlike HDF5, Parquet natively stores complex data structures in a columnar format and doesn't need to be wrapped by an interpretation layer like ``awkward.hdf5``. Like HDF5 and unlike Arrow, Parquet is a file format, intended for storage.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\nb = awkward.fromiter([[1.1, 2.2, None, 3.3, None],\n                      [4.4, [5.5]],\n                      [{\"x\": 6, \"y\": {\"z\": 7}}, None, {\"x\": 8, \"y\": {\"z\": 9}}]\n                     ])\n\n# %%\nawkward.toparquet(\"dataset.parquet\", a)\n\n# %%\na2 = awkward.fromparquet(\"dataset.parquet\")\na2\n# <ChunkedArray [[1.1 2.2 3.3] [] [4.4 5.5]] at 0x78110846dc50>\n\n# %%markdown\n# Notice that we get a ``ChunkedArray`` back. This is because ``awkward.fromparquet`` is lazy-loading the Parquet file, which might be very large (not in this case, obviously). It's actually a ``ChunkedArray`` (one `row group <https://parquet.apache.org/documentation/latest/#unit-of-parallelization>`__ per chunk) of ``VirtualArrays``, and each ``VirtualArray`` is read when it is accessed (for instance, to print it above).\n\n# %%\na2.chunks\n# [<VirtualArray [[1.1 2.2 3.3] [] [4.4 5.5]] at 0x78110846dc18>]\n\n# %%\na2.chunks[0].array\n# <BitMaskedArray [[1.1 2.2 3.3] [] [4.4 5.5]] at 0x78110849aeb8>\n\n# %%markdown\n# The next layer of new structure is that the jagged array is bit-masked. Even though none of the values are nullable, this is an artifact of the way Parquet formats columnar data.\n\n# %%\na2.chunks[0].array.content\n# <JaggedArray [[1.1 2.2 3.3] [] [4.4 5.5]] at 0x78110849a518>\n\n# %%\na2.layout\n#  layout\n# [           ()] ChunkedArray(chunks=[layout[0]], chunksizes=[3])\n# [            0]   VirtualArray(generator=<awkward.arrow._ParquetFile object at 0x78110846df98>, args=(0, ''), kwargs={}, array=layout[0, 0])\n# [         0, 0]     BitMaskedArray(mask=layout[0, 0, 0], content=layout[0, 0, 1], maskedwhen=False, lsborder=True)\n# [      0, 0, 0]       ndarray(shape=1, dtype=dtype('uint8'))\n# [      0, 0, 1]       JaggedArray(starts=layout[0, 0, 1, 0], stops=layout[0, 0, 1, 1], content=layout[0, 0, 1, 2])\n# [   0, 0, 1, 0]         ndarray(shape=3, dtype=dtype('int32'))\n# [   0, 0, 1, 1]         ndarray(shape=3, dtype=dtype('int32'))\n# [   0, 0, 1, 2]         BitMaskedArray(mask=layout[0, 0, 1, 2, 0], content=layout[0, 0, 1, 2, 1], maskedwhen=False, lsborder=True)\n# [0, 0, 1, 2, 0]           ndarray(shape=1, dtype=dtype('uint8'))\n# [0, 0, 1, 2, 1]           ndarray(shape=5, dtype=dtype('float64'))\n\n# %%markdown\n# Fewer types can be written to Parquet files than Arrow buffers, since pyarrow does not yet have a complete Arrow → Parquet transformation.\n\n# %%\ntry:\n    awkward.toparquet(\"dataset2.parquet\", b)\nexcept Exception as err:\n    print(type(err), str(err))\n# <class 'pyarrow.lib.ArrowNotImplementedError'> Unhandled type for Arrow to Parquet schema conversion: union[dense]<0: double=0, 1: list<item: double>=1, 2: struct<x: int64, y: struct<z: int64>>=2>\n\n# %%markdown\n# * ``awkward.topandas(array, flatten=False)``: convert the array into a Pandas DataFrame (if tabular) or a Pandas Series (otherwise). If ``flatten=False``, wrap the awkward arrays as a new Pandas extension type (not fully implemented). If ``flatten=True``, convert the jaggedness and nested tables into row and column ``pandas.MultiIndex`` without introducing any new types (not always possible).\n\n# %%\na = awkward.Table(x=awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6, 7.7, 8.8, 9.9]]),\n                  y=awkward.fromiter([100, 200, 300, 400]))\ndf = awkward.topandas(a)\ndf\n\nif False:\n      [<table border=\\\"1\\\" class=\\\"dataframe\\\">\\n\",\n       \"  <thead>\\n\",\n       \"    <tr style=\\\"text-align: right;\\\">\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>x</th>\\n\",\n       \"      <th>y</th>\\n\",\n       \"    </tr>\\n\",\n       \"  </thead>\\n\",\n       \"  <tbody>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>[1.1 2.2 3.3]</td>\\n\",\n       \"      <td>100</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>[]</td>\\n\",\n       \"      <td>200</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <td>[4.4 5.5]</td>\\n\",\n       \"      <td>300</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>3</th>\\n\",\n       \"      <td>[6.6 7.7 8.8 9.9]</td>\\n\",\n       \"      <td>400</td>\\n\",\n       \"    </tr>\\n\",\n       \"  </tbody>\\n\",\n       \"</table>\\n\"]\n\n# %%\ndf.x\n# 0        [1.1 2.2 3.3]\n# 1                   []\n# 2            [4.4 5.5]\n# 3    [6.6 7.7 8.8 9.9]\n# Name: x, dtype: awkward\n\n# %%markdown\n# Note that the ``dtype`` is ``awkward``. The array has not been converted into Numpy ``dtype=object`` (which would imply a performance loss); it has been wrapped as a container that Pandas recognizes. You can get the awkward array back the same way you would a Numpy array:\n\n# %%\ndf.x.values\n# <JaggedSeries [[1.1 2.2 3.3] [] [4.4 5.5] [6.6 7.7 8.8 9.9]] at 0x78110846d400>\n\n# %%markdown\n# (``JaggedSeries`` is a thin wrapper on ``JaggedArray``; they behave the same way.)\n#\n# The value of this is that awkward slice semantics can be applied to data in Pandas.\n\n# %%\ndf[1:]\n\nif False:\n      [<table border=\\\"1\\\" class=\\\"dataframe\\\">\\n\",\n       \"  <thead>\\n\",\n       \"    <tr style=\\\"text-align: right;\\\">\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>x</th>\\n\",\n       \"      <th>y</th>\\n\",\n       \"    </tr>\\n\",\n       \"  </thead>\\n\",\n       \"  <tbody>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>[]</td>\\n\",\n       \"      <td>200</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <td>[4.4 5.5]</td>\\n\",\n       \"      <td>300</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>3</th>\\n\",\n       \"      <td>[6.6 7.7 8.8 9.9]</td>\\n\",\n       \"      <td>400</td>\\n\",\n       \"    </tr>\\n\",\n       \"  </tbody>\\n\",\n       \"</table>\\n\"]\n\n# %%\ndf.x[df.x.values.counts > 0]\n# 0        [1.1 2.2 3.3]\n# 2            [4.4 5.5]\n# 3    [6.6 7.7 8.8 9.9]\n# Name: x, dtype: awkward\n\n# %%markdown\n# However, Pandas has a (limited) way of handling jaggedness and nested tables, with ``pandas.MultiIndex`` rows and columns, respectively.\n\n# %%\n# Nested tables become MultiIndex-valued column names.\narray = awkward.fromiter([{\"a\": {\"b\": 1, \"c\": {\"d\": [2]}}, \"e\": 3},\n                          {\"a\": {\"b\": 4, \"c\": {\"d\": [5, 5.1]}}, \"e\": 6},\n                          {\"a\": {\"b\": 7, \"c\": {\"d\": [8, 8.1, 8.2]}}, \"e\": 9}])\ndf = awkward.topandas(array, flatten=True)\ndf\n\nif False:\n      [\"<table border=\\\"1\\\" class=\\\"dataframe\\\">\\n\",\n       \"  <thead>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th colspan=\\\"2\\\" halign=\\\"left\\\">a</th>\\n\",\n       \"      <th>e</th>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>b</th>\\n\",\n       \"      <th>c</th>\\n\",\n       \"      <th></th>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>d</th>\\n\",\n       \"      <th></th>\\n\",\n       \"    </tr>\\n\",\n       \"  </thead>\\n\",\n       \"  <tbody>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>1</td>\\n\",\n       \"      <td>2.0</td>\\n\",\n       \"      <td>3</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"2\\\" valign=\\\"top\\\">1</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>4</td>\\n\",\n       \"      <td>5.0</td>\\n\",\n       \"      <td>6</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>4</td>\\n\",\n       \"      <td>5.1</td>\\n\",\n       \"      <td>6</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"3\\\" valign=\\\"top\\\">2</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>7</td>\\n\",\n       \"      <td>8.0</td>\\n\",\n       \"      <td>9</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>7</td>\\n\",\n       \"      <td>8.1</td>\\n\",\n       \"      <td>9</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <td>7</td>\\n\",\n       \"      <td>8.2</td>\\n\",\n       \"      <td>9</td>\\n\",\n       \"    </tr>\\n\",\n       \"  </tbody>\\n\",\n       \"</table>\\n\"]\n\n# %%\n# Jagged arrays become MultiIndex-valued rows (index).\narray = awkward.fromiter([{\"a\": 1, \"b\": [[2.2, 3.3, 4.4], [], [5.5, 6.6]]},\n                          {\"a\": 10, \"b\": [[1.1], [2.2, 3.3], [], [4.4]]},\n                          {\"a\": 100, \"b\": [[], [9.9]]}])\ndf = awkward.topandas(array, flatten=True)\ndf\n\nif False:\n      [\"<table border=\\\"1\\\" class=\\\"dataframe\\\">\\n\",\n       \"  <thead>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>a</th>\\n\",\n       \"      <th>b</th>\\n\",\n       \"    </tr>\\n\",\n       \"  </thead>\\n\",\n       \"  <tbody>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"5\\\" valign=\\\"top\\\">0</th>\\n\",\n       \"      <th rowspan=\\\"3\\\" valign=\\\"top\\\">0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>1</td>\\n\",\n       \"      <td>2.2</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>1</td>\\n\",\n       \"      <td>3.3</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <td>1</td>\\n\",\n       \"      <td>4.4</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"2\\\" valign=\\\"top\\\">2</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>1</td>\\n\",\n       \"      <td>5.5</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>1</td>\\n\",\n       \"      <td>6.6</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"4\\\" valign=\\\"top\\\">1</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>10</td>\\n\",\n       \"      <td>1.1</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"2\\\" valign=\\\"top\\\">1</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>10</td>\\n\",\n       \"      <td>2.2</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>10</td>\\n\",\n       \"      <td>3.3</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>3</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>10</td>\\n\",\n       \"      <td>4.4</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>100</td>\\n\",\n       \"      <td>9.9</td>\\n\",\n       \"    </tr>\\n\",\n       \"  </tbody>\\n\",\n       \"</table>\\n\"]\n\n# %%markdown\n# The advantage of this is that no new column types are introduced, and Pandas already has functions for managing structure in its ``MultiIndex``. For instance, this structure can be unstacked into Pandas's columns.\n\n# %%\ndf.unstack()\n\nif False:\n      [\"<table border=\\\"1\\\" class=\\\"dataframe\\\">\\n\",\n       \"  <thead>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th colspan=\\\"3\\\" halign=\\\"left\\\">a</th>\\n\",\n       \"      <th colspan=\\\"3\\\" halign=\\\"left\\\">b</th>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <th>2</th>\\n\",\n       \"    </tr>\\n\",\n       \"  </thead>\\n\",\n       \"  <tbody>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"2\\\" valign=\\\"top\\\">0</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>1.0</td>\\n\",\n       \"      <td>1.0</td>\\n\",\n       \"      <td>1.0</td>\\n\",\n       \"      <td>2.2</td>\\n\",\n       \"      <td>3.3</td>\\n\",\n       \"      <td>4.4</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <td>1.0</td>\\n\",\n       \"      <td>1.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>5.5</td>\\n\",\n       \"      <td>6.6</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th rowspan=\\\"3\\\" valign=\\\"top\\\">1</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>10.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>1.1</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>10.0</td>\\n\",\n       \"      <td>10.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>2.2</td>\\n\",\n       \"      <td>3.3</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>3</th>\\n\",\n       \"      <td>10.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>4.4</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>100.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>9.9</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"    </tr>\\n\",\n       \"  </tbody>\\n\",\n       \"</table>\\n\"]\n\n# %%\ndf.unstack().unstack()\n\nif False:\n      [\"<table border=\\\"1\\\" class=\\\"dataframe\\\">\\n\",\n       \"  <thead>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th colspan=\\\"10\\\" halign=\\\"left\\\">a</th>\\n\",\n       \"      <th>...</th>\\n\",\n       \"      <th colspan=\\\"10\\\" halign=\\\"left\\\">b</th>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th colspan=\\\"4\\\" halign=\\\"left\\\">0</th>\\n\",\n       \"      <th colspan=\\\"4\\\" halign=\\\"left\\\">1</th>\\n\",\n       \"      <th colspan=\\\"2\\\" halign=\\\"left\\\">2</th>\\n\",\n       \"      <th>...</th>\\n\",\n       \"      <th colspan=\\\"2\\\" halign=\\\"left\\\">0</th>\\n\",\n       \"      <th colspan=\\\"4\\\" halign=\\\"left\\\">1</th>\\n\",\n       \"      <th colspan=\\\"4\\\" halign=\\\"left\\\">2</th>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <th>3</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <th>3</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <th>...</th>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <th>3</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <th>3</th>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <th>3</th>\\n\",\n       \"    </tr>\\n\",\n       \"  </thead>\\n\",\n       \"  <tbody>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>1.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>1.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>1.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>1.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>1.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>...</td>\\n\",\n       \"      <td>5.5</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>3.3</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>6.6</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>4.4</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>10.0</td>\\n\",\n       \"      <td>10.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>10.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>10.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>...</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>4.4</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>3.3</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>100.0</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>...</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"      <td>NaN</td>\\n\",\n       \"    </tr>\\n\",\n       \"  </tbody>\\n\",\n       \"</table>\\n\"]\n\n# %%markdown\n# It is also possible to get `Pandas Series and DataFrames through Arrow <https://arrow.apache.org/docs/python/pandas.html>`__, though this doesn't handle jagged arrays well: they get converted into Numpy ``dtype=object`` arrays.\n\n# %%\ndf = awkward.toarrow(array).to_pandas()\ndf\n\nif False:\n      [\"<table border=\\\"1\\\" class=\\\"dataframe\\\">\\n\",\n       \"  <thead>\\n\",\n       \"    <tr style=\\\"text-align: right;\\\">\\n\",\n       \"      <th></th>\\n\",\n       \"      <th>a</th>\\n\",\n       \"      <th>b</th>\\n\",\n       \"    </tr>\\n\",\n       \"  </thead>\\n\",\n       \"  <tbody>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>0</th>\\n\",\n       \"      <td>1</td>\\n\",\n       \"      <td>[[2.2, 3.3, 4.4], [], [5.5, 6.6]]</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>1</th>\\n\",\n       \"      <td>10</td>\\n\",\n       \"      <td>[[1.1], [2.2, 3.3], [], [4.4]]</td>\\n\",\n       \"    </tr>\\n\",\n       \"    <tr>\\n\",\n       \"      <th>2</th>\\n\",\n       \"      <td>100</td>\\n\",\n       \"      <td>[[], [9.9]]</td>\\n\",\n       \"    </tr>\\n\",\n       \"  </tbody>\\n\",\n       \"</table>\\n\"]\n\n# %%\ndf.b\n# 0    [[2.2, 3.3, 4.4], [], [5.5, 6.6]]\n# 1       [[1.1], [2.2, 3.3], [], [4.4]]\n# 2                          [[], [9.9]]\n# Name: b, dtype: object\n\n# %%\ndf.b[0]\n# array([array([2.2, 3.3, 4.4]), array([], dtype=float64),\n#        array([5.5, 6.6])], dtype=object)\n\n# %%markdown\n# # High-level types\n#\n# The high-level type of an array describes its characteristics in terms of what it *represents*, a *logical* view of the data. By contrast, the layouts (below) describe the nested arrays themselves, a *physical* view of the data.\n#\n# The logical view of Numpy arrays is described in terms of ``shape`` and ``dtype``. The awkward type of a Numpy array is presented a little differently.\n\n# %%\na = numpy.array([[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]])\nt = awkward.type.fromarray(a)\nt\n# ArrayType(3, 2, dtype('float64'))\n\n# %%markdown\n# Above is the object-form of the high-level type and object that ``takes`` arguments ``to`` return values.\n\n# %%\nt.takes\n# 3\n\n# %%\nt.to\n# ArrayType(2, dtype('float64'))\n\n# %%\nt.to.to\n# dtype('float64')\n\n# %%markdown\n# High-level type objects also have a printable form for human readability.\n\n# %%\nprint(t)\n# [0, 3) -> [0, 2) -> float64\n\n# %%markdown\n# The above should be read like a function's data type: ``argument type -> return type`` for the function that takes an index in square brackets and returns something else. For example, the first ``[0, 3)`` means that you could put any non-negative integer less than ``3`` in square brackets after the array, like this:\n\n# %%\na[2]\n# array([5.5, 6.6])\n\n# %%markdown\n# The second ``[0, 2)`` means that the next argument can be any non-negative integer less than ``2``.\n\n# %%\na[2][1]\n# 6.6\n\n# %%markdown\n# And then you have a Numpy ``dtype``.\n#\n# The reason high-level types are expressed like this, instead of Numpy ``shape`` and ``dtype`` is to generalize to arbitrary objects.\n\n# %%\na = awkward.fromiter([{\"x\": 1, \"y\": []}, {\"x\": 2, \"y\": [1.1, 2.2]}, {\"x\": 3, \"y\": [1.1, 2.2, 3.3]}])\nprint(a.type)\n# [0, 3) -> 'x' -> int64\n#           'y' -> [0, inf) -> float64\n\n# %%markdown\n# In the above, you could call ``a[2][\"x\"]`` to get ``3`` or ``a[2][\"y\"][1]`` to get ``2.2``, but the types and even number of allowed arguments depend on which path you take. Numpy's ``shape`` and ``dtype`` have no equivalent.\n#\n# Also in the above, the allowed argument for the jagged array is specified as ``[0, inf)``, which doesn't literally mean any value up to infinity is allowed—the constraint simply isn't specific because it depends on the details of the jagged array. Even specifying the maximum length of any sublist (``a[\"y\"].counts.max()``) would require a calculation that scales with the size of the dataset, which can be infeasible in some cases. Instead, ``[0, inf)`` simply means \"jagged.\"\n#\n# Fixed-length arrays inside of ``JaggedArrays`` or ``Tables`` are presented with known upper limits:\n\n# %%\na = awkward.Table(x=[[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]],\n                  y=awkward.fromiter([[1, 2, 3], [], [4, 5]]))\nprint(a.type)\n# [0, 3) -> 'x' -> [0, 2) -> float64\n#           'y' -> [0, inf) -> int64\n\n# %%markdown\n# Whereas each value of a ``Table`` row (`product type <https://en.wikipedia.org/wiki/Product_type>`__) contains a member of every one of its fields, each value of a ``UnionArray`` item (`sum type <https://en.wikipedia.org/wiki/Tagged_union>`__) contains a member of exactly one of its possibilities. The distinction is drawn as the lack or presence of a vertical bar (meaning \"or\": ``|``).\n\n# %%\na = awkward.fromiter([{\"x\": 1, \"y\": \"one\"}, {\"x\": 2, \"y\": \"two\"}, {\"x\": 3, \"y\": \"three\"}])\nprint(a.type)\n# [0, 3) -> 'x' -> int64\n#           'y' -> <class 'str'>\n\n# %%\na = awkward.fromiter([1, 2, 3, \"four\", \"five\", \"six\"])\nprint(a.type)\n# [0, 6) -> (int64         |\n#            <class 'str'> )\n\n# %%markdown\n# The parenthesis is to keep ``Table`` fields from being mixed up with ``UnionArray`` possibilities.\n\n# %%\na = awkward.fromiter([{\"x\": 1, \"y\": 1.1}, {\"x\": 2, \"y\": 2.2}, {\"x\": 3, \"y\": \"three\"}, {\"x\": 4, \"y\": \"four\"}])\nprint(a.type)\n# [0, 4) -> 'x' -> int64\n#           'y' -> (float64       |\n#                   <class 'str'> )\n\n# %%markdown\n# As in mathematics, products and the adjacency operator take precedence over sums.\n\n# %%\na = awkward.fromiter([1, 2, 3, {\"x\": 4.4, \"y\": \"four\"}, {\"x\": 5.5, \"y\": \"five\"}, {\"x\": 6.6, \"y\": \"six\"}])\nprint(a.type)\n# [0, 6) -> (int64                |\n#            'x' -> float64\n#            'y' -> <class 'str'> )\n\n# %%markdown\n# Missing data, represented by ``MaskedArrays``, ``BitMaskedArrays``, or ``IndexedMaskedArrays``, are called \"option types\" in the high-level type language.\n\n# %%\na = awkward.fromiter([1, 2, 3, None, None, 4, 5])\nprint(a.type)\n# [0, 7) -> ?(int64)\n\n# %%\n# Inner arrays could be missing values.\na = awkward.fromiter([[1.1, 2.2, 3.3], None, [4.4, 5.5]])\nprint(a.type)\n# [0, 3) -> ?([0, inf) -> float64)\n\n# %%\n# Numbers in those arrays could be missing values.\na = awkward.fromiter([[1.1, 2.2, None], [], [4.4, 5.5]])\nprint(a.type)\n# [0, 3) -> [0, inf) -> ?(float64)\n\n# %%markdown\n# Cross-references and cyclic references are expressed in awkward type objects by creating the same graph structure among the type objects as the arrays. Thus,\n\n# %%\ntree = awkward.fromiter([\n    {\"value\": 1.23, \"left\":    1, \"right\":    2},     # node 0\n    {\"value\": 3.21, \"left\":    3, \"right\":    4},     # node 1\n    {\"value\": 9.99, \"left\":    5, \"right\":    6},     # node 2\n    {\"value\": 3.14, \"left\":    7, \"right\": None},     # node 3\n    {\"value\": 2.71, \"left\": None, \"right\":    8},     # node 4\n    {\"value\": 5.55, \"left\": None, \"right\": None},     # node 5\n    {\"value\": 8.00, \"left\": None, \"right\": None},     # node 6\n    {\"value\": 9.00, \"left\": None, \"right\": None},     # node 7\n    {\"value\": 0.00, \"left\": None, \"right\": None},     # node 8\n])\nleft = tree.contents[\"left\"].content\nright = tree.contents[\"right\"].content\nleft[(left < 0) | (left > 8)] = 0         # satisfy overzealous validity checks\nright[(right < 0) | (right > 8)] = 0\ntree.contents[\"left\"].content = awkward.IndexedArray(left, tree)\ntree.contents[\"right\"].content = awkward.IndexedArray(right, tree)\n\ntree[0].tolist()\n# {'left': {'left': {'left': {'left': None, 'right': None, 'value': 9.0},\n#    'right': None,\n#    'value': 3.14},\n#   'right': {'left': None,\n#    'right': {'left': None, 'right': None, 'value': 0.0},\n#    'value': 2.71},\n#   'value': 3.21},\n#  'right': {'left': {'left': None, 'right': None, 'value': 5.55},\n#   'right': {'left': None, 'right': None, 'value': 8.0},\n#   'value': 9.99},\n#  'value': 1.23}\n\n# %%markdown\n# In the print-out, labels (``T0 :=``, ``T1 :=``, ``T2 :=``) are inserted to indicate where cross-references begin and end.\n\n# %%\nprint(tree.type)\n[0, 9) -> 'left'  -> T0 := ?(T1 := 'left'  -> T0\n                                   'right' -> T2 := ?(T1)\n                                   'value' -> float64)\n          'right' -> T2\n          'value' -> float64\n\n# %%markdown\n# The ``ObjectArray`` class turns awkward array structures into Python objects on demand. From an analysis point of view, the elements of the array *are* Python objects, and that is reflected in the type.\n\n# %%\nclass Point:\n    def __init__(self, x, y):\n        self.x, self.y = x, y\n    def __repr__(self):\n        return \"Point({0}, {1})\".format(self.x, self.y)\n\na = awkward.fromiter([Point(0, 0), Point(3, 2), Point(1, 1), Point(2, 4), Point(0, 0)])\na\n# <ObjectArray [Point(0, 0) Point(3, 2) Point(1, 1) Point(2, 4) Point(0, 0)] at 0x781106089390>\n\n# %%\nprint(a.type)\n# [0, 5) -> <function ObjectFillable.finalize.<locals>.make at 0x781106085a60>\n\n# %%markdown\n# In summary,\n#\n# * each element of a Numpy ``shape`` like ``(i, j, k)`` becomes a functional argument: ``[0, i) -> [0, j) -> [0, k)``;\n# * high-level types terminate on Numpy ``dtypes`` or ``ObjectArray`` functions;\n# * columns of a ``Table`` are presented adjacent to one another: the type is field 1 *and* field 2 *and* field 3, etc.;\n# * possibilities of a ``UnionArray`` are separated by vertical bars ``|``: the type is possibility 1 *or* possibility 2 *or* possibility 3, etc.;\n# * nullable types are indicated by a question mark;\n# * cross-references and cyclic references are maintained in the type objects, printed with labels.\n\n# %%markdown\n# # Low-level layouts\n#\n# The layout of an array describes how it is constructed in terms of Numpy arrays and other parameters. It has more information than a high-level type (above), more that would typically be needed for data analysis, but very necessary for data engineering.\n#\n# A ``Layout`` object is a mapping from position tuples to ``LayoutNodes``. The screen representation is sufficient for reading.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])\nt = a.layout\nt\n#  layout\n# [    ()] JaggedArray(starts=layout[0], stops=layout[1], content=layout[2])\n# [     0]   ndarray(shape=3, dtype=dtype('int64'))\n# [     1]   ndarray(shape=3, dtype=dtype('int64'))\n# [     2]   ndarray(shape=5, dtype=dtype('float64'))\n\n# %%\nt[2]\n# <LayoutNode [(2,)] ndarray>\n\n# %%\nt[2].array\n# array([1.1, 2.2, 3.3, 4.4, 5.5])\n\n# %%\na = awkward.fromiter([[[1.1, 2.2], [3.3]], [], [[4.4, 5.5]]])\nt = a.layout\nt\n#  layout\n# [    ()] JaggedArray(starts=layout[0], stops=layout[1], content=layout[2])\n# [     0]   ndarray(shape=3, dtype=dtype('int64'))\n# [     1]   ndarray(shape=3, dtype=dtype('int64'))\n# [     2]   JaggedArray(starts=layout[2, 0], stops=layout[2, 1], content=layout[2, 2])\n# [  2, 0]     ndarray(shape=3, dtype=dtype('int64'))\n# [  2, 1]     ndarray(shape=3, dtype=dtype('int64'))\n# [  2, 2]     ndarray(shape=5, dtype=dtype('float64'))\n\n# %%\nt[2]\n# <LayoutNode [(2,)] JaggedArray>\n\n# %%\nt[2].array\n# <JaggedArray [[1.1 2.2] [3.3] [4.4 5.5]] at 0x7811060a1208>\n\n# %%\nt[2, 2].array\n# array([1.1, 2.2, 3.3, 4.4, 5.5])\n\n# %%markdown\n# Classes like ``IndexedArray``, ``SparseArray``, ``ChunkedArray``, ``AppendableArray``, and ``VirtualArray`` don't change the high-level type of an array, but they do change the layout. Consider, for instance, an array made with ``awkward.fromiter`` and an array read by ``awkward.fromparquet``.\n\n# %%\na = awkward.fromiter([[1.1, 2.2, None, 3.3], [], None, [4.4, 5.5]])\n\n# %%\nawkward.toparquet(\"tmp.parquet\", a)\n\n# %%\nb = awkward.fromparquet(\"tmp.parquet\")\n\n# %%markdown\n# At first, it terminates at ``VirtualArray`` because the data haven't been read—we don't know what arrays are associated with it.\n\n# %%\nb.layout\n#  layout\n# [    ()] ChunkedArray(chunks=[layout[0]], chunksizes=[4])\n# [     0]   VirtualArray(generator=<awkward.arrow._ParquetFile object at 0x781106089668>, args=(0, ''), kwargs={})\n\n# %%markdown\n# But after reading,\n\n# %%\nb\n# <ChunkedArray [[1.1 2.2 None 3.3] [] [] [4.4 5.5]] at 0x7811060890b8>\n\n# %%markdown\n# The layout shows that it has more structure than ``a``.\n\n# %%\nb.layout\n#  layout\n# [           ()] ChunkedArray(chunks=[layout[0]], chunksizes=[4])\n# [            0]   VirtualArray(generator=<awkward.arrow._ParquetFile object at 0x781106089668>, args=(0, ''), kwargs={}, array=layout[0, 0])\n# [         0, 0]     BitMaskedArray(mask=layout[0, 0, 0], content=layout[0, 0, 1], maskedwhen=False, lsborder=True)\n# [      0, 0, 0]       ndarray(shape=1, dtype=dtype('uint8'))\n# [      0, 0, 1]       JaggedArray(starts=layout[0, 0, 1, 0], stops=layout[0, 0, 1, 1], content=layout[0, 0, 1, 2])\n# [   0, 0, 1, 0]         ndarray(shape=4, dtype=dtype('int32'))\n# [   0, 0, 1, 1]         ndarray(shape=4, dtype=dtype('int32'))\n# [   0, 0, 1, 2]         BitMaskedArray(mask=layout[0, 0, 1, 2, 0], content=layout[0, 0, 1, 2, 1], maskedwhen=False, lsborder=True)\n# [0, 0, 1, 2, 0]           ndarray(shape=1, dtype=dtype('uint8'))\n# [0, 0, 1, 2, 1]           ndarray(shape=6, dtype=dtype('float64'))\n\n# %%\na.layout\n#  layout\n# [     ()] MaskedArray(mask=layout[0], content=layout[1], maskedwhen=True)\n# [      0]   ndarray(shape=4, dtype=dtype('bool'))\n# [      1]   JaggedArray(starts=layout[1, 0], stops=layout[1, 1], content=layout[1, 2])\n# [   1, 0]     ndarray(shape=4, dtype=dtype('int64'))\n# [   1, 1]     ndarray(shape=4, dtype=dtype('int64'))\n# [   1, 2]     MaskedArray(mask=layout[1, 2, 0], content=layout[1, 2, 1], maskedwhen=True)\n# [1, 2, 0]       ndarray(shape=6, dtype=dtype('bool'))\n# [1, 2, 1]       ndarray(shape=6, dtype=dtype('float64'))\n\n# %%markdown\n# However, they have the same high-level type.\n\n# %%\nprint(b.type)\n# [0, 4) -> ?([0, inf) -> ?(float64))\n\n# %%\nprint(a.type)\n# [0, 4) -> ?([0, inf) -> ?(float64))\n\n# %%markdown\n# Cross-references and cyclic references are also encoded in the ``layout``, as references to previously seen indexes.\n\n# %%\ntree.layout\n#  layout\n# [     ()] Table(left=layout[0], right=layout[1], value=layout[2])\n# [      0]   MaskedArray(mask=layout[0, 0], content=layout[0, 1], maskedwhen=True)\n# [   0, 0]     ndarray(shape=9, dtype=dtype('bool'))\n# [   0, 1]     IndexedArray(index=layout[0, 1, 0], content=layout[0, 1, 1])\n# [0, 1, 0]       ndarray(shape=9, dtype=dtype('int64'))\n# [0, 1, 1]       -> layout[()]\n# [      1]   MaskedArray(mask=layout[1, 0], content=layout[1, 1], maskedwhen=True)\n# [   1, 0]     ndarray(shape=9, dtype=dtype('bool'))\n# [   1, 1]     IndexedArray(index=layout[1, 1, 0], content=layout[1, 1, 1])\n# [1, 1, 0]       ndarray(shape=9, dtype=dtype('int64'))\n# [1, 1, 1]       -> layout[()]\n# [      2]   ndarray(shape=9, dtype=dtype('float64'))\n\n# %%markdown\n# # Applications\n\n# %%markdown\n# ## Decision tree as an awkward array\n\n# %%markdown\n# ## Mixed-source data with persistvirtual\n\n# %%markdown\n# ## Using Pandas with awkward arrays\n\n# %%markdown\n# ## Using Numba with awkward arrays\n\n# %%markdown\n# ## Flattening awkard arrays for machine learning\n", "meta": {"hexsha": "e91fe1c352673401c2aa953baf27bf78cacdded3", "size": 188405, "ext": "py", "lang": "Python", "max_stars_repo_path": "docs/frontpage-source.py", "max_stars_repo_name": "smit2k14/awkward-array", "max_stars_repo_head_hexsha": "a2645fdaed1a6997c4677ae47cbb2cd0663e8a21", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "docs/frontpage-source.py", "max_issues_repo_name": "smit2k14/awkward-array", "max_issues_repo_head_hexsha": "a2645fdaed1a6997c4677ae47cbb2cd0663e8a21", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/frontpage-source.py", "max_forks_repo_name": "smit2k14/awkward-array", "max_forks_repo_head_hexsha": "a2645fdaed1a6997c4677ae47cbb2cd0663e8a21", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.2243388615, "max_line_length": 1982, "alphanum_fraction": 0.5823200021, "include": true, "reason": "import numpy,import numba", "num_tokens": 63865, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46101677931231594, "lm_q2_score": 0.15817434481176187, "lm_q1q2_score": 0.07292102701495419}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# In the [last notebook](https://github.com/caiomiyashiro/RecommenderSystemsNotebooks/blob/master/Month%202%20Part%20I%20-%20User%20User%20Collaborative%20Filtering.ipynb), we took a look at the Nearest Neighboor User User CF, a form of recommender system that looked at the similarity between users to define which item should be suggested to a new customer.\n# \n# We saw the benefits from User User CF when comparing it to non personalised and content based recommendations, but we also saw that it comes with one difficulty.\n# \n# - It doesn't scale well. Even in a big e-commerce dataset, the amount of intersecting items between 2 users is not as big as it could be when User User CF was created. Because of this, when a user bought an item that intersected now with another different customer, the new similarity could drastically change, causing the system's owners to recalculate the new similarities very often.\n#   \n# - If they don't update the matrix often, they can also lose profits over it because it wouldn't map the user's short term interests which, on the internet, can vary quite a lot.\n# \n# All in all, short term interest and sparse mutual interest space make the User User CF inapt for high scale companies.\n# \n# # Item Item Collaborative Filtering (CF)\n# \n# [Item Item CF](https://en.wikipedia.org/wiki/Item-item_collaborative_filtering) was created by ([Sarwar et all, 1998](https://patentimages.storage.googleapis.com/41/80/fb/07d4d9e61e7431/US6266649.pdf)) in partneship with Amazon in order to fix the problems with the User User CF. In Item Item perspective, as the name suggests, changes the perspective from User centered to a Item centered view, *i.e.*, instead of having a User User similarity matrix, they started to use a item item similarity matrix. Then, when a user $u$ bought and liked an item $i_{1}$ and $i_{1}$ was similar to item $i_{2}$, then we predicted that $u$ would also like $i_{2}$. Take a look at the image below:\n# \n# <img src=\"images/notebook5_image1.jpeg\" width=\"500\">\n# \n# Why this simple change in perspective helped to solve the inneficiency problems present in the User User CF?\n# \n# By considering an enviroment of a big e-commerce company, we end with the number of users >> number of items.   \n# In this case, even if a single user hasn't given many reviews, the chances are that many users have given a review to a specific item.\n# By having a big number of reviews, an item relationship to other items doesn't change too much by receiving a few more reviews, *i.e.*, item item relationship are more stable. Therefore, by being more stable, the similarity matrix doesn't have to be recalculated often, as in the User User CF.\n#   \n# An extra perfomance improvement comes also from the prediction calculation. In the Item Item CF, a new prediction for a user $u$ for a product $p$ is made by retrieving the items similarities and calculating a weighted average. The number of neighboors for this calculation is only the item that $u$ has liked or bought in the past and this number is often small enought. Therefore, we don't need to search the big user user similarity matrix to find the best $k$ neighboors.\n# \n# # Item Item Steps\n# \n# As always, we're going to work with one of the datasets from the [Coursera's Specialization on Recommender Systems](https://www.coursera.org/specializations/recommender-systems). This dataset is from the last week in the course of [Nearest Neighboors CF](https://www.coursera.org/learn/collaborative-filtering) for Item Item CF. Dataset is [here](https://d396qusza40orc.cloudfront.net/umntestsite/on-demand_files/A5/Assignment%205.xls) (Coursera's page) and [here](https://github.com/caiomiyashiro/RecommenderSystemsNotebooks/blob/master/data/Item%20Item%20Collaborative%20Filtering%20-%20Ratings.csv) (personal Github account).\n#   \n# The steps taken to evaluate and recommend are similar to User User CF, with some different calculations in the prediction step, as we've said.\n# \n# - Load traditional input - User Item Review dataset\n# - Create similarity matrix\n# - Make predictions\n# \n# Lets go!\n# \n# ## Example Dataset\n# \n# The dataset is a matrix with size 25 users x 25 movies and each cell $c_{u,m}$ contains the rating user $u$ gave to movie $m$. If user $u$ didn't rate movie $m$, the cell is empty. As the float values were stored with commas and consequently were being casted as strings, I had to process it a little bit to replace the commas for dots and then convert the column to floats\n\n# In[1]:\n\n\nimport pandas as pd\nimport numpy as np\n\n\n# In[2]:\n\n\ndf = pd.read_csv('data/Item Item Collaborative Filtering - Ratings.csv', index_col=0, nrows=20)\n\ndf.drop('Mean', axis=1, inplace=True) # remove mean column that comes at the end\n\n# replace commas for dots and convert previous string column into float\ndef processCol(col):\n    return col.astype(str).apply(lambda val: val.replace(',','.')).astype(float)\ndf = df.apply(processCol)\n\nprint('Dataset shape: ' + str(df.shape))\ndf.head()\n\n\n# ## Create Similarity Matrix\n# \n# \n# ### Similarity Function\n# \n# As for the User User CF, we have a few possibilities to choose from when deciding how we're going to define if an item is similar to another item. Again, ([Herlocker et all, 2002](https://grouplens.org/site-content/uploads/evaluating-TOIS-20041.pdf)) did an analysis on the performance of these metrics on Item Item CF and realised that, for this case, the [cosine similarity](https://en.wikipedia.org/wiki/Cosine_similarity) was the best performant metric. So we're going with them this time. On the **next notebook**, we try to analyse these metrics and see why it performs better in certain cases and others not.\n# \n# \n# ## Calculating User User Similarity with Cosine Similarity:\n# \n# One important point here is on the calculation of the denominator of the cosine similarity. Even though we make the dot product only with values existing in both arrays, the norm of the individual vectors are considering all values, and not the intersections between array1 and array2.\n\n# In[3]:\n\n\ndef cos_similarity(item1, item2):\n    item1Values = ~np.isnan(item1)\n    item2Values = ~np.isnan(item2)\n    allValues = np.logical_and(item1Values,item2Values) # get only existent elements of both vectors\n    return np.dot(item1[allValues], item2[allValues])/(np.linalg.norm(item1[item1Values]) * np.linalg.norm(item2[item2Values]))\n\ndef pre_cos_similarity(item1, df):\n    return df.apply(lambda item2: cos_similarity(item1, item2))\n\ndf_corr = df.apply(lambda item1: pre_cos_similarity(item1, df))\ndf_corr.head()\n\n\n# ## Predictions Calculation\n# \n# By now we already know which items are more similar to each other. This will help us when predicting a new rating, by giving higher weights for more similar items than other the user has bough. \n#   \n# The way we're going to calculate the new predictions is the same we used for User User CF, *i.e.*, a weighted average:\n# \n# $$\\frac{\\sum_{n=1}^{k} r_{n}w_{n}}{\\sum_{n=1}^{k} w_{n}}$$\n#   \n# The difference is that we don't have the neighboors anymore, so the $n$ in the summation is considering **all** the items user $u$ has rated and $w$ is still the similarities, but now *item similarity*.\n\n# In[4]:\n\n\ndef predictRating(userRatings, itemSimilarity):\n    userHasRating = ~np.isnan(userRatings)\n    return np.dot(userRatings[userHasRating], itemSimilarity[userHasRating])/np.sum(itemSimilarity[userHasRating])\n\ndef pre_predictRating(userRatings, df_corr):\n    return df_corr.apply(lambda itemSimilarity: predictRating(userRatings, itemSimilarity))\n\npredictions = df.apply(lambda userRatings: pre_predictRating(userRatings, df_corr), axis=1)\npredictions.head()    \n\n\n# ## Mean Normalised Weighted Average\n# \n# As in the same way of the User User CF, we can calculate predictions using the absolute value of the reviews or from the mean centralised values of it. The advantages are the same: consider the scale variability of reviewers when attributing a final score for a item of interest:\n# \n# $$\\bar{r_{u}} + \\frac{\\sum_{n=1}^{k} (r_{n} - \\bar{r_{n}})w_{n}}{\\sum_{n=1}^{k} w_{n}}$$\n# \n# We took the same function as above, but added two extra parameters:\n# - $userMeanRating$: mean average ratings for a specific user\n# - $neighboorsMeanRating$: mean average rating for all the nearest neighboors for a specific user\n\n# In[5]:\n\n\n# mean normalise\ndef subtractFromMean(col, meanCol):\n    result = np.array([np.nan] * col.shape[0])\n    isValidValue = ~np.isnan(col)\n    result[isValidValue] = col.values[isValidValue] - meanCol.values[isValidValue]\n    return result\nuserMeanRatings = df.apply(np.mean, axis=1)\ndf_ratings_norm = df.apply(lambda col: subtractFromMean(col, userMeanRatings))\n\n# similarity matrix\ndf_corr_norm = df_ratings_norm.apply(lambda item1: pre_cos_similarity(item1, df_ratings_norm))\n\n\n# ### Remove negative correlations\n# \n# In this example, we are replacing the negative correlations by 0, as we can interpret as a maximum weight for unwanted items:\n# \n\n# In[6]:\n\n\ndef replaceNegative(col):\n    col[col < 0] = 0\n    return col\ndf_corr_norm2 = df_corr_norm.apply(replaceNegative)\n\n\n# ### Predict!\n\n# In[7]:\n\n\npredictions_norm = df.apply(lambda userRatings: pre_predictRating(userRatings, df_corr_norm2), axis=1)\npredictions_norm.head() \n\n\n# * I didn't quite understand why we didn't use the not normalised item's ratings in this calculation. Ideally, we would use the mean centered user ratings as well..\n\n# # Comparison Between Approaches\n# \n# The comparison follows the same guidelines we used when evaluating the User User CF. \n# \n# \n# # Final Considerations on User User CF\n# \n# When we mean centered the user's rating for the User User CF, the objective was clear, we wanted to take into account that users rate in different parts of the scale. But what about mean centering for the Item Item CF? This evaluation I'll leave it to the next notebook, where we evaluate and compare the main metrics used for similarity calculation in a CF system.\n# \n# -- \n# \n# Item Item CF brings efficiencies steps forward from the User User CF schema. With it, we bring personalised recommendations and in a way that is computationally efficient to scale for giant e-commerce companies, such as Amazon or Netflix. But Item Item CF isn't a gold system, where we can implement it and always get good results. It has a few premisses:\n# \n# - First, it has the premisse that number of users >> number of items. This is a prerequisite to have stable entities, items in this case, and doesn't need to recalculate the similarity matrix often, as in the User User CF.\n#   \n#   \n# - Secondly, and this is an interesting feature, Item Item CF is better when the item ratings are stable, *i.e.*, they have lots of evaluations. This means that the user's items are probably going to have a lot of influence from these popular items and, at the end, receiving popular items recommendations. This is good when you want to be safe about your recommendations, such as expensive services or products or rarely bought, such as houses or cars. However, this lack of '*serendipity*' is missed when we want to enable users to find that particular rare item and amazingly matched with your tastes. As an example, If we take Spotify, we don't want to receive recommendations such as 'Hey, as you listened to Mozart, here is what we think you'd like: Bach'. Spotify greatness works on the premisse of finding the bands and songs that can surprise you, so they wouldn't be effective by working on the Item Item CF schema. Of course, we are going to see more advance techniques in the future where these companies apply modern algorithms to have good recommendations and still be performatic, but the idea now was to show how we can't rely on one algorithm as the best of them all.\n# \n# <img src=\"images/notebook5_image2.png\" width=\"500\">\n#   \n#   \n# In the [next notebook](https://github.com/caiomiyashiro/RecommenderSystemsNotebooks/blob/master/Month%202%20Part%20III%20-%20Notes%20on%20Similarity%20Metrics%20for%20CF.ipynb), we finalise the discussion over Collaborative Filtering by investigating a little more on how the similarity metrics work and try to find out some of its features such as:  \n#   \n# * Why pearson end up being better for User User CF and Cosine Similarity better for Item Item CF?\n# * What are the strenghts and weakness when thinking on using one of the evaluated metrics?\n# * Some filosophies on what they represent and how we can think about them geometrically\n#   \n# Stay tuned :)\n", "meta": {"hexsha": "dcd3964a787c63295fd717c616a2d994609eba7f", "size": 12536, "ext": "py", "lang": "Python", "max_stars_repo_path": "code/nbs/reco-tut-asr-99-05-item-item-cf.py", "max_stars_repo_name": "sparsh-ai/reco-tut-asr", "max_stars_repo_head_hexsha": "d64b6ed02826933e8add8f83a5773c5a0a21896b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "code/nbs/reco-tut-asr-99-05-item-item-cf.py", "max_issues_repo_name": "sparsh-ai/reco-tut-asr", "max_issues_repo_head_hexsha": "d64b6ed02826933e8add8f83a5773c5a0a21896b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/nbs/reco-tut-asr-99-05-item-item-cf.py", "max_forks_repo_name": "sparsh-ai/reco-tut-asr", "max_forks_repo_head_hexsha": "d64b6ed02826933e8add8f83a5773c5a0a21896b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 63.3131313131, "max_line_length": 1185, "alphanum_fraction": 0.7601308232, "include": true, "reason": "import numpy", "num_tokens": 3072, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4687906266262437, "lm_q2_score": 0.1540575568655563, "lm_q1q2_score": 0.07222073861951231}}
{"text": "# -*- coding: utf-8 -*-\n# Copyright (c) 2013 - 2019, Gorka Zamora-López <gorka@Zamora-Lopez.xyz>\n#\n# Released under the Apache License, Version 2.0 (the \"License\");\n# you may not use this software except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http://www.apache.org/licenses/LICENSE-2.0\n\n\"\"\"\nGraph Analysis Library\n======================\n\nA package for the analysis of graphs and complex networks in Python.\nCompatible with Python 2.7 and 3.X\n\nGAlib treats networks as adjacency matrices, represented as 2D NumPy arrays,\nthus taking advantage of the faster operations over pure Pythen data types.\nThe core of the library consists of three modules:\n\nmetrics\n    Basic graph metrics (degrees, clustering, graph distance, etc)\nmodels\n    Generation of synthetic networks and randomization.\ntools\n    Miscelaneous helper functions.\n\nThe rest of modules provide additional functionalities:\n\nmetrics_numba\n    Uses package Numba to accelerate calculation of some metrics.\nmodels_numba\n    Uses package Numba to accelerate generation of some graph models.\nextra.py\n    Additional measures and functionalities related to network analysis.\n\nUSING pyGAlib\n^^^^^^^^^^^^^^\nThe library is organised in the following modules:\n\n- *metrics.py*: Common graph metrics (degrees, clustering, graph distance, etc)\n- *models.py*: Generation of synthetic networks and randomization.\n- *tools.py*: Miscelaneous helper functions.\n- *metrics_numba.py*: Uses the Numba package to accelerate calculation of some\nmetrics.\n- *models_numba.py*: Uses the Numba package to accelerate generation of some\ngraph models.\n- *extra.py*: Additional measures and functionalities related to network analysis.\n\nGetting started\n***************\nSince pyGAlib depends on NumPy, it is recommended to import NumPy first.\nAlthough this is not necessary for loading pyGAlib, NumPy functionalities and\narray manipulation will be often needed. Try importing pyGAlib: ::\n\n    >>> import numpy as np\n    >>> import galib\n\n..note::\n    Importing galib imports also all functions in module *metrics.py*\n    into its namespace. The rest of modules are imported separately. Therefore,\n    if the import is relative those functions can be called as, e.g.,\n\n::\n\n    >>> import galib\n    >>> ...\n    >>> deg = galib.Degree(net)\n    >>> C, Cnodes = galib.Clustering(net)\n\nSee that we did not have to call ``galib.metrics.Degree(net)``. In the case of\nan absolute import (using an asterisk ``*``) all functions in *metrics.py* are\nimported to the base namespace:  ::\n\n    >>> from galib import *\n    >>> ...\n    >>> deg = Degree(net)\n    >>> C, Cnodes = Clustering(net)\n\nExample\n*******\nLet's generate a random graph following the Erdos-Renyi model, G(N,p), with\n*N = 100* nodes and link probability *p = 0.1*:  ::\n\n    >>> import galib\n    >>> import galib.models\n    >>> N = 100; p = 0.1\n    >>> net = galib.models.ErdosRenyiGraph(N, p, directed=False)\n\nHere, *net* is the adjacency matrix of the random graph represented as a\n2-dimensional NumPy array. Let's calculate some basic properties.  ::\n\n    >>> galib.Density(net)\n    0.09838383838383838\n\nAs expected, the density of an Erdos-Renyi random graph is close to the\n*p = 0.1* value given. We now calculate the degree of every node:  ::\n\n    >>> deg = galib.Degree(net)\n    >>> deg\n    array([10,  7, 10, 10, 11,  7,  5, 11, 13, 12, 14, 13,  8, 10,  9,  8,  7,\n       10, 11,  9, 11, 11,  8, 10,  5,  9, 13, 10, 13, 12, 12, 11, 11,  7,\n       13, 11,  7, 10, 10,  6, 12, 10,  6, 10,  7,  6,  9, 10,  9,  9,  7,\n        9,  8, 13, 10,  9,  7,  7, 11,  8, 13,  6,  7, 12, 14,  6,  5, 11,\n        5, 12, 14, 14, 13,  8,  7, 12,  4, 19,  9, 13,  7, 10, 15, 15,  4,\n        9,  7, 12,  7,  8, 12,  4, 11, 12,  6, 13,  6, 12, 16, 12])\n\nThe degree is returned as a numpy array of rank 1, of integer type. The function\n``Clustering()`` returns both the global clustering coefficient and the local\nclustering of every node:  ::\n\n    >>> C, Cnodes = galib.Clustering(net)\n    >>> C\n    0.096051227321238\n    >>> Cnodes\n    array([0.13333333, 0.04761905, 0.04444444, 0.08888889, 0.10909091,\n       0.19047619, 0.3       , 0.12727273, 0.08974359, 0.06060606,\n      \t... ... ...\n      \t... ... ...\n       0.04545455, 0.        , 0.10909091, 0.13636364, 0.        ,\n       0.07692308, 0.13333333, 0.09090909, 0.08333333, 0.10606061])\n\nWe compute the pair-wise graph distance between all the nodes using the\nFloyd-Warshall algorithm, which is returned as a matrix ``dij`` (numpy array of\nrank 2):  ::\n\n\t>>> dij = galib.FloydWarshall(net)\n\t>>> avlen = (dij.sum() - dij.trace()) / (N*(N-1))\n\t>>> avlen\n\t2.248080808080808\n\n.. note::\n    For calculating the distance matrix of larger networks please use\n    the version of the function located in the module *metrics_numba.py*. Here,\n    the function ``FloydWarshall_Numba()`` works the same but makes use of the\n    Numba library to significantly speed the calculation.\n\nMost network generators and graph metrics in pyGAlib work with directed graphs\nas well. Check for the optional parameter ``directed``. Following the example\nabove, we generate a directed Erdos-Renyi graph and calculate its input and\noutput degrees for every node:  ::\n\n    >>> net = galib.models.ErdosRenyiGraph(N, p, directed=True)\n    >>> galib.Density(net)\n    0.10272727272727272\n    >>> indeg, outdeg = galib.Degree(net, directed=True)\n    >>> indeg\n    array([17,  7,  9,  8, 11, 10,  9,  8, 13, 13,  5,  9, 13,  9, 10, 10, 13,\n       10,  9,  9,  7, 11, 13, 10,  4, 15, 11, 11, 10,  6,  6,  8,  8,  8,\n       11,  8,  4, 12,  8, 13, 13, 14, 12,  5,  6,  5, 16, 12,  5, 10,  9,\n       13,  8,  9,  7,  8, 13, 14,  9, 18,  7, 11,  5,  4, 12,  8,  8, 10,\n        7,  9, 15, 12, 14,  9, 15, 11, 13, 12, 15, 10, 11, 11, 15,  7, 10,\n       13,  7, 14,  9, 16, 11, 11,  6, 18,  7,  4, 14, 12, 12, 10])\n    >>> outdeg\n    array([ 9, 10,  7,  9, 12,  9, 19,  9, 11, 16, 11, 12, 11, 15, 11,  6,  9,\n        8, 11, 12,  9, 13,  9,  8, 11,  6,  7, 11, 11, 12, 10,  8, 11, 12,\n       10, 12, 13,  8, 18, 11,  8, 13, 10,  8, 10, 10, 11,  8, 11, 11, 11,\n       10, 11, 10,  9, 12,  6, 10,  7, 10, 10, 11, 15, 12, 11,  7, 10,  8,\n        5, 11,  7, 11, 13,  8,  5,  6, 13, 11, 10, 13,  7,  6, 13, 11,  8,\n        8, 10,  6, 10,  9, 12, 15, 11,  9, 15, 11,  7,  8, 11, 10])\n\nData I/O\n********\nSince GAlib is based on NumPy arrays, saving and reading of adjacency matrices,\nas well as any other output of GAlib functions, can be performed using the usual\ndata I/O functionalities of NumPy. See for example the documentation for\nfunctions: ``loadtxt()``, ``savetxt()``, ``load()``, ``save()`` and ``savez()``.\nThe *tools.py* module in pyGAlib provides also some data conversion\nfunctionalities.\n\nHow to find further documentation\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nWhile working in an interactive session, after importing a module, the built-in\n``help()`` function will show further details:  ::\n\n    >>> help(modulename)\n\nThe help for galib (``help(galib)``) shows the general summary of the package\nand a list of all the modules in the library. The help for each module,\ne.g., ``help(galib.metrics)`` or ``help(galib.models)`` will display module\nspecific information and a list of all the functions in the module. For further\ndetails regarding each function, type:  ::\n\n    >>> help(galib.modulename.functionname)\n\nFor IPython and Jupyter notebook users the help command is replaced by a\nquestion mark after the module's or function's name, e.g.:  ::\n\n    >>> modulename?\n    >>> functionname?\n\nFor questions, bug reports, etc, please write to <galib@Zamora-Lopez.xyz>, or\nopen an issue in GitHub.\n\nLicense\n-------\n\nCopyright (c) 2013 - 2019, Gorka Zamora-López <gorka@Zamora-Lopez.xyz>\n\nReleased under the Apache License, Version 2.0 (the \"License\");\nyou may not use this software except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nor see the LICENSE.txt file.\n\n.. note::\n    Please, use the logos provided in the Branding/ folder whenever possible.\n\n\"\"\"\nfrom __future__ import absolute_import\n\nfrom . import metrics\nfrom .metrics import*\n\n\n__author__ = \"Gorka Zamora-Lopez\"\n__email__ = \"galib@Zamora-Lopez.xyz\"\n__copyright__ = \"Copyright 2013-2020\"\n__license__ = \"Apache License version 2.0\"\n__version__ = \"1.1.2\"\n__update__=\"15/06/2020\"\n\n\n\n#\n", "meta": {"hexsha": "53f671382c732012f4e62ac9f1e65e04a55758eb", "size": 8351, "ext": "py", "lang": "Python", "max_stars_repo_path": "galib/__init__.py", "max_stars_repo_name": "decolab/pyGAlib", "max_stars_repo_head_hexsha": "89945c1f41412164f4acca9428cd52133b709750", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2015-08-11T14:17:29.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-06T15:08:06.000Z", "max_issues_repo_path": "galib/__init__.py", "max_issues_repo_name": "decolab/pyGAlib", "max_issues_repo_head_hexsha": "89945c1f41412164f4acca9428cd52133b709750", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2015-06-14T12:08:29.000Z", "max_issues_repo_issues_event_max_datetime": "2018-12-04T10:14:42.000Z", "max_forks_repo_path": "galib/__init__.py", "max_forks_repo_name": "gorkazl/pyGAlib", "max_forks_repo_head_hexsha": "89945c1f41412164f4acca9428cd52133b709750", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2015-06-10T19:00:10.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-26T19:03:50.000Z", "avg_line_length": 36.6271929825, "max_line_length": 82, "alphanum_fraction": 0.6520177224, "include": true, "reason": "import numpy", "num_tokens": 2906, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.14414885487109627, "lm_q1q2_score": 0.07207442743554814}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.4'\n#       jupytext_version: 1.2.4\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# <div style='background-image: url(\"../share/images/header.svg\") ; padding: 0px ; background-size: cover ; border-radius: 5px ; height: 250px'>\n#     <div style=\"float: right ; margin: 50px ; padding: 20px ; background: rgba(255 , 255 , 255 , 0.7) ; width: 50% ; height: 150px\">\n#         <div style=\"position: relative ; top: 50% ; transform: translatey(-50%)\">\n#             <div style=\"font-size: xx-large ; font-weight: 900 ; color: rgba(0 , 0 , 0 , 0.8) ; line-height: 100%\">Scientific Python</div>\n#             <div style=\"font-size: large ; padding-top: 20px ; color: rgba(0 , 0 , 0 , 0.5)\">A super quick crash course</div>\n#         </div>\n#     </div>\n# </div>\n\n# Seismo-Live: http://seismo-live.org\n#\n# ##### Authors:\n# * Lion Krischer ([@krischer](https://github.com/krischer))\n#\n# ---\n\n# This notebook is a very quick introduction to Python and in particular its scientific ecosystem in case you have never seen it before. It furthermore grants a possibility to get to know the [IPython/Jupyter notebook](http://www.nature.com/news/interactive-notebooks-sharing-the-code-1.16261). [See here for the official documentation](http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Notebook%20Basics.ipynb) of the Jupyter notebook - a ton more information can be found online.\n#\n#\n# A lot of motivational writing on *Why Python?* is out there so we will not repeat it here and just condense it to a single sentence: **Python is a good and easy to learn, open-source, general purpose programming language that happens to be very good for many scientific tasks (due to its vast scientific ecosystem).**\n#\n#\n# #### Quick Reference on How to Use This Notebook\n#\n#\n# <img src=\"images/notebook_toolbar.png\" style=\"width:70%\"></img>\n#\n# * `Shift + Enter`: Execute cell and jump to the next cell\n# * `Ctrl/Cmd + Enter`: Execute cell and don't jump to the next cell\n#\n#\n# #### Disclaimer\n#\n# The tutorials are employing Jupyter notebooks but these are only one way of using Python. Writing scripts to text files and executing them with the Python interpreter of course also works:\n#\n# ```bash\n# $ python do_something.py\n# ```\n#\n# Another alternative is interactive usage on the command line:\n#\n# ```bash\n# $ ipython\n# ```\n#\n# ## Notebook Setup\n#\n# First things first: In many notebooks you will find a cell similar to the following one. **Always execute it!** They do a couple of things:\n# * Make plots appear in the browser (otherwise a window pops up)\n# * Printing things works like this:\n#\n# ```python\n# print(\"Hello\")\n# ```\n#\n# This essentially makes the notebooks work under Python 2 and Python 3.\n#\n# * Plots look quite a bit nicer (this is optional).\n#\n\n# +\n# Plots now appear in the notebook.\n# %matplotlib inline\n\nimport matplotlib.pyplot as plt\nplt.style.use('ggplot')                            # Matplotlib style sheet - nicer plots!\nplt.rcParams['figure.figsize'] = 12, 8             # Slightly bigger plots by default\n# -\n\n# ---\n#\n# ## Useful Links\n#\n# Here is collection of resources regarding the scientific Python ecosystem. They cover a number of different packages and topics; way more than we will manage today.\n#\n# If you have any question regarding some specific Python functionality you can consult the official [Python documenation](http://docs.python.org/).\n#\n# Furthermore a large number of Python tutorials, introductions, and books are available online. Here are some examples for those interested in learning more.\n#\n# * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)\n# * [Dive Into Python](http://www.diveintopython.net/)\n# * [The Official Python Tutorial](http://docs.python.org/2/tutorial/index.html)\n# * [Think Python Book](http://www.greenteapress.com/thinkpython/thinkpython.html)\n#\n# Some people might be used to Matlab - this helps:\n#\n# * [NumPy for Matlab Users Introdution](http://wiki.scipy.org/NumPy_for_Matlab_Users)\n# * [NumPy for Matlab Users Cheatsheet](http://mathesaurus.sourceforge.net/matlab-numpy.html)\n#\n#\n# Additionally there is an abundance of resources introducing and teaching parts of the scientific Python ecosystem.\n#\n# * [NumPy Tutorial](http://wiki.scipy.org/Tentative_NumPy_Tutorial)\n# * [Probabilistic Programming and Bayesian Methods for Hackers](http://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/): Great ebook introducing Bayesian methods from an understanding-first point of view with the examples done in Python.\n# * [Python Scientific Lecture Notes](http://scipy-lectures.github.io/): Introduces the basics of scientific Python with lots of examples.\n# * [Python for Signal Processing](http://python-for-signal-processing.blogspot.de/): Free blog which is the basis of a proper book written on the subject.\n# * [Another NumPy Tutorial](http://www.loria.fr/~rougier/teaching/numpy/numpy.html), [Matplotlib Tutorial](http://www.loria.fr/~rougier/teaching/matplotlib/matplotlib.html)\n#\n# You might eventually have a need to create some custom plots. The quickest way to success is usually to start from some example that is somewhat similar to what you want to achieve and just modify it. These websites are good starting points:\n#\n# * [Matplotlib Gallery](http://matplotlib.org/gallery.html)\n# * [ObsPy Gallery](http://docs.obspy.org/gallery.html)\n# * [Basemap Gallery](http://matplotlib.org/basemap/users/examples.html)\n#\n#\n# ---\n\n# ## Core Python Crash Course\n#\n# This course is fairly non-interactive and serves to get you up to speed with Python assuming you have practical programming experience with at least one other language. Nonetheless please change things and play around an your own - it is the only way to really learn it!\n#\n# The first part will introduce you to the core Python language. This tutorial uses Python 3 but almost all things can be transferred to Python 2. If possible choose Python 3 for your own work!\n#\n#\n# ### 1. Numbers\n#\n# Python is dynamically typed and assigning something to a variable will give it that type.\n\n# +\n# Three basic types of numbers\na = 1             # Integers\nb = 2.0           # Floating Point Numbers\nc = 3.0 + 4j      # Complex Numbers, note the use of j for the complex part\n\n\n# Arithmetics work as expected.\n# Upcasting from int -> float -> complex\nd = a + b         # (int + float = float)\nprint(d)\n\ne = c ** 2        # c to the second power, performs a complex multiplication\nprint(e)\n# -\n\n# ### 2. Strings\n\n# Just enclose something in single or double quotes and it will become a string. On Python 3 it defaults to unicode strings, e.g. non Latin alphabets and other symbols.\n\n# +\n# You can use single or double quotes to create strings.\nlocation = \"New York\"\n\n# Concatenate strings with plus.\nwhere_am_i = 'I am in ' + location\n\n# Print things with the print() function.\nprint(location, 1, 2)\nprint(where_am_i)\n\n# Strings have a lot of attached methods for common manipulations.\nprint(location.lower())\n\n# Access single items with square bracket. Negative indices are from the back.\nprint(location[0], location[-1])\n\n# Strings can also be sliced.\nprint(location[4:])\n# -\n\n# #### Exercise\n#\n# Save your name in all lower-case letters to a variable, and print a capitalized version of it. Protip: [Google for \"How to capitalize a string in python\"](http://www.google.com/search?q=how+to+capitalize+a+string+in+python). This works for almost any programming problem - someone will have had the same issue before!\n\n# + {\"tags\": [\"exercise\"]}\n\n\n# + {\"tags\": [\"solution\"]}\nname = \"lion\"\nprint(name.capitalize())\n# -\n\n# ### 3. Lists\n\n# Python has two main collection types: List and dictionaries. The former is just an ordered collection of objects and is introduced here.\n\n# +\n# List use square brackets and are simple ordered collections of things.\neverything = [a, b, c, 1, 2, 3, \"hello\"]\n\n# Access elements with the same slicing/indexing notation as strings.\n# Note that Python indices are zero based!\nprint(everything[0])\nprint(everything[:3])\nprint(everything[2:-2])\n\n# Negative indices are counted from the back of the list.\nprint(everything[-3:])\n\n# Append things with the append method.\neverything.append(\"you\")\nprint(everything)\n# -\n\n# ### 4. Dictionaries\n#\n# The other main collection type in Python are dictionaries. They are similiar to associative arrays or (hash) maps in other languages. Each entry is a key-value pair.\n\n# +\n# Dictionaries have named fields and no inherent order. As is\n# the case with lists, they can contain anything.\ninformation = {\n    \"name\": \"Hans\",\n    \"surname\": \"Mustermann\",\n    \"age\": 78,\n    \"kids\": [1, 2, 3]\n}\n\n# Acccess items by using the key in square brackets.\nprint(information[\"kids\"])\n\n# Add new things by just assigning to a key.\nprint(information)\ninformation[\"music\"] = \"jazz\"\nprint(information)\n\n# Delete things by using the del operator\ndel information[\"age\"]\nprint(information)\n\n\n# -\n\n# ### 5. Functions\n#\n# The key to conquer a big problem is to divide it into many smaller ones and tackle them one by one. This is usually achieved by using functions.\n\n# +\n# Functions are defined using the def keyword.\ndef do_stuff(a, b):\n    return a * b\n\n# And called with the arguments in round brackets.\nprint(do_stuff(2, 3))\n\n# Python function also can have optional arguments.\ndef do_more_stuff(a, b, power=1):\n    return (a * b) ** power\n\nprint(do_more_stuff(2, 3))\nprint(do_more_stuff(2, 3, power=3))\n\n# For more complex function it is oftentimes a good idea to\n#explicitly name the arguments. This is easier to read and less error-prone.\nprint(do_more_stuff(a=2, b=3, power=3))\n# -\n\n# ### 6. Imports\n#\n# To use functions and objects not part of the default namespace, you have import them. You will have to do this a lot so it is necessary to learn how to do it.\n\n# +\n# Import anything, and use it with the dot accessor.\nimport math\n\na = math.cos(4 * math.pi)\n\n# You can also selectively import things.\nfrom math import pi\n\nb = 3 * pi\n\n# And even rename them if you don't like their name.\nfrom math import cos as cosine\nc = cosine(b)\n# -\n\n# How to know what is available?\n#\n# 1. Read the [documentation](https://docs.python.org/3/library/math.html)\n# 2. Interactively query the module\n\nprint(dir(math))\n\n# Typing the dot and the TAB will kick off tab-completion.\n\n# math.\n\n# In the IPython framework you can also use a question mark to view the documentation of modules and functions.\n\n# math.cos?\n\n# ### 7. Control Flow\n#\n# Loops and conditionals are needed for any non-trivial task. Please note that **whitespace matters in Python**. Everything that is indented at the same level is part of the same block. By far the most common loops in Python are for-each loops as shown in the following. While loops also exist but are rarely used.\n\n# +\ntemp = [\"a\", \"b\", \"c\"]\n\n# The typical Python loop is a for-each loop, e.g.\nfor item in temp:\n    # Everything with the same indentation is part of the loop.\n    new_item = item + \" \" + item\n    print(new_item)\n\nprint(\"No more part of the loop.\")\n# -\n\n# Useful to know is the range() function.\nfor i in range(5):\n    print(i)\n\n# The second crucial control flow structure are if/else conditional and they work the same as in any other language.\n\n# +\n# If/else works as expected.\nage = 77\n\nif age >= 0 and age < 10:\n    print(\"Younger than ten.\")\nelif age >= 10:\n    print(\"Older than ten.\")\nelse:\n    print(\"Wait what?\")\n\n# +\n# List comprehensions are a nice way to write compact loops.\n# Make sure you understand this as it is very common in Python.\n\na = list(range(10))\nprint(a)\nb = [i for i in a if not i % 2]\nprint(b)\n\n# Equivalant loop for b.\nb = []\nfor i in a:\n    if not i % 2:\n        b.append(i)\nprint(b)\n\n\n# -\n\n# ### 8. Error Messages\n#\n# You will eventually run into some error messages. Learn to read them! The last line is often the one that matters - reading upwards traces the error back in time and shows what calls led to it. If stuck: just google the error message!\n\n# +\ndef do_something(a, b):\n    print(a + b + something_else)\n\n# do_something(1, 2)\n# -\n\n# ## The Scientific Python Ecosystem\n#\n# The [SciPy Stack](https://www.scipy.org/stackspec.html) forms the basis for essentially all applications of scientific Python. Here we will quickly introduce the three core libraries:\n#\n# * `NumPy`\n# * `SciPy`\n# * `Matplotlib`\n#\n# The SciPy stack furthermore contains `pandas` (library for data analysis on tabular and time series data) and `sympy` (package for symbolic math), both very powerful packages, but we will omit them in this tutorial.\n\n# ### 9. NumPy\n#\n# Large parts of the scientific Python ecosystem use NumPy, an array computation package offering N-dimensional, typed arrays and useful functions for linear algebra, Fourier transforms, random numbers, and other basic scientific tasks.\n\n# +\nimport numpy as np\n\n# Create a large array with with 1 million samples.\nx = np.linspace(start=0, stop=100, num=1E6, dtype=np.float64)\n\n# Most operations work per-element.\ny = x ** 2\n\n# Uses C and Fortran under the hood for speed.\nprint(y.sum())\n\n# FFT and inverse\nx = np.random.random(100)\nlarge_X = np.fft.fft(x)\nx = np.fft.ifft(large_X)\n# -\n\n# ### 10. SciPy\n#\n# `SciPy`, in contrast to `NumPy` which only offers basic numerical routines, contains a lot of additional functionality needed for scientific work. Examples are solvers for basic differential equations, numeric integration and optimization, spare matrices, interpolation routines, signal processing methods, and a lot of other things.\n\n# +\nfrom scipy.interpolate import interp1d\n\nx = np.linspace(0, 10, num=11, endpoint=True)\ny = np.cos(-x ** 2 / 9.0)\n\n# Cubic spline interpolation to new points.\nf2 = interp1d(x, y, kind='cubic')(np.linspace(0, 10, num=101, endpoint=True))\n# -\n\n# ### 11. Matplotlib\n#\n# Plotting is done using `Matplotlib`, a package for greating high-quality static plots. It has an interface that mimics Matlab which many people are familiar with.\n\n# +\nimport matplotlib.pyplot as plt\n\nplt.plot(np.sin(np.linspace(0, 2 * np.pi, 2000)), color=\"green\",\n         label=\"Some Curve\")\nplt.legend()\nplt.ylim(-1.1, 1.1)\nplt.show()\n# -\n\n# ## Exercises\n#\n# #### Functions, NumPy, and Matplotlib\n#\n# A. Write a function that takes a NumPy array `x` and `a`, `b`, and `c` and returns\n#\n# $$\n# f(x) = a x^2 + b x + c\n# $$\n#\n# B. Plot the result of that function with matplotlib.\n\n# + {\"tags\": [\"exercise\"]}\n\n\n# + {\"tags\": [\"solution\"]}\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndef simple_poly(x, a, b, c):\n    return a * x ** 2 + b * x + c\n\nplt.plot(simple_poly(np.linspace(-5, 5), 10, 2, 2))\nplt.show()\n# -\n\n# #### 99 Bottles of Beer\n#\n# *(stolen from http://www.ling.gu.se/~lager/python_exercises.html)*\n#\n#\n# \"99 Bottles of Beer\" is a traditional song in the United States and Canada. It is popular to sing on long trips, as it has a very repetitive format which is easy to memorize, and can take a long time to sing. The song's simple lyrics are as follows:\n#\n# ```\n# 99 bottles of beer on the wall, 99 bottles of beer.\n# Take one down, pass it around, 98 bottles of beer on the wall.\n# ```\n#\n# The same verse is repeated, each time with one fewer bottle. The song is completed when the singer or singers reach zero.\n#\n# Your task here is write a Python program capable of generating all the verses of the song.\n#\n\n# + {\"tags\": [\"exercise\"]}\n\n\n# + {\"tags\": [\"solution\"]}\nprint(\"99 bottles of beer on the wall, 99 bottles of beer.\")\nfor i in range(98, -1, -1):\n    print(\"Take one down, pass it around, %i bottles of beer on the wall.\" % i)\n# -\n\n# #### Ceasar Cipher\n#\n# *(stolen from http://www.ling.gu.se/~lager/python_exercises.html)*\n#\n# In cryptography, a Caesar cipher is a very simple encryption techniques in which each letter in the plain text is replaced by a letter some fixed number of positions down the alphabet. For example, with a shift of 3, A would be replaced by D, B would become E, and so on. The method is named after Julius Caesar, who used it to communicate with his generals. ROT-13 (\"rotate by 13 places\") is a widely used example of a Caesar cipher where the shift is 13. In Python, the key for ROT-13 may be represented by means of the following dictionary:\n#\n# ```python\n# key = {'a':'n', 'b':'o', 'c':'p', 'd':'q', 'e':'r', 'f':'s', 'g':'t', 'h':'u',\n#        'i':'v', 'j':'w', 'k':'x', 'l':'y', 'm':'z', 'n':'a', 'o':'b', 'p':'c',\n#        'q':'d', 'r':'e', 's':'f', 't':'g', 'u':'h', 'v':'i', 'w':'j', 'x':'k',\n#        'y':'l', 'z':'m', 'A':'N', 'B':'O', 'C':'P', 'D':'Q', 'E':'R', 'F':'S',\n#        'G':'T', 'H':'U', 'I':'V', 'J':'W', 'K':'X', 'L':'Y', 'M':'Z', 'N':'A',\n#        'O':'B', 'P':'C', 'Q':'D', 'R':'E', 'S':'F', 'T':'G', 'U':'H', 'V':'I',\n#        'W':'J', 'X':'K', 'Y':'L', 'Z':'M'}\n# ```\n#\n# Your task in this exercise is to implement an decoder of ROT-13. Once you're done, you will be able to read the following secret message:\n#\n# ```\n# Pnrfne pvcure? V zhpu cersre Pnrfne fnynq!\n# ```\n#\n# **BONUS:** Write an encoder!\n\n# + {\"tags\": [\"exercise\"]}\n\n\n# + {\"tags\": [\"solution\"]}\nsentence = \"Pnrfne pvcure? V zhpu cersre Pnrfne fnynq!\"\n\nkey = {'a':'n', 'b':'o', 'c':'p', 'd':'q', 'e':'r', 'f':'s', 'g':'t', 'h':'u',\n       'i':'v', 'j':'w', 'k':'x', 'l':'y', 'm':'z', 'n':'a', 'o':'b', 'p':'c',\n       'q':'d', 'r':'e', 's':'f', 't':'g', 'u':'h', 'v':'i', 'w':'j', 'x':'k',\n       'y':'l', 'z':'m', 'A':'N', 'B':'O', 'C':'P', 'D':'Q', 'E':'R', 'F':'S',\n       'G':'T', 'H':'U', 'I':'V', 'J':'W', 'K':'X', 'L':'Y', 'M':'Z', 'N':'A',\n       'O':'B', 'P':'C', 'Q':'D', 'R':'E', 'S':'F', 'T':'G', 'U':'H', 'V':'I',\n       'W':'J', 'X':'K', 'Y':'L', 'Z':'M'}\n\nresult = \"\"\nfor letter in sentence:\n    if letter not in key:\n        result += letter\n    else:\n        result += key[letter]\nprint(result)\n", "meta": {"hexsha": "fb5bf12ec7a4c14847ebaa330bed42985400fc1c", "size": 17936, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks/Python Introduction/Python_Crash_Course_solution.py", "max_stars_repo_name": "krischer/seismo_live_build", "max_stars_repo_head_hexsha": "e4e8e59d9bf1b020e13ac91c0707eb907b05b34f", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-07-11T10:01:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-16T14:26:03.000Z", "max_issues_repo_path": "notebooks/Python Introduction/Python_Crash_Course_solution.py", "max_issues_repo_name": "krischer/seismo_live_build", "max_issues_repo_head_hexsha": "e4e8e59d9bf1b020e13ac91c0707eb907b05b34f", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "notebooks/Python Introduction/Python_Crash_Course_solution.py", "max_forks_repo_name": "krischer/seismo_live_build", "max_forks_repo_head_hexsha": "e4e8e59d9bf1b020e13ac91c0707eb907b05b34f", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-11-11T05:05:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-12T09:36:24.000Z", "avg_line_length": 34.7596899225, "max_line_length": 545, "alphanum_fraction": 0.6791369313, "include": true, "reason": "import numpy,from scipy", "num_tokens": 4887, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3106943959796865, "lm_q2_score": 0.2309197682220399, "lm_q1q2_score": 0.0717454779075159}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# <!-- HTML file automatically generated from DocOnce source (https://github.com/doconce/doconce/)\n# doconce format html hw2.do.txt --no_mako -->\n# <!-- dom:TITLE: PHY321: Classical Mechanics 1 -->\n\n# # PHY321: Classical Mechanics 1\n# **Homework 2, due January 28 (Midnight)**\n# \n# Date: **Jan 18, 2022**\n\n# ### Practicalities about  homeworks and projects\n# \n# 1. You can work in groups (optimal groups are often 2-3 people) or by yourself. If you work as a group you can hand in one answer only if you wish. **Remember to write your name(s)**!\n# \n# 2. Homeworks are available 10 days  before the deadline.\n# \n# 3. How do I(we)  hand in?  You can hand in the paper and pencil exercises as a  scanned  document. For this homework this applies to exercises 1-5. The scanned document should be uploaded to D2L. Alternatively, you can hand in everyhting (if you are ok with typing mathematical formulae using say Latex) as a jupyter notebook at D2L. The numerical exercise(s) (exercise 6 here) should always be handed in as a jupyter notebook by the deadline at D2L.\n\n# ### Exercise 1 (10 pt), Forces, discussion questions, test your intuition\n# \n# * 1a (2pt) Single force. Can an object affected only by a single force have zero acceleration?\n# \n# * 1b (2pt) Zero velocity. If you throw a ball vertically it has zero velocity at its maximum point. Does it also have zero acceleration at this point?\n# \n# * 1c (3pt) Acceleration of gravity. You measure the acceleration of gravity in an elevator moving at a velocity of 9.8m/s downwards. What will you measure?\n# \n# * 1d (3pt) Air resistance. You throw a ball straight up and measure the velocity as it passes you on its way down. Will the velocity be larger, the same, or smaller if you did the same experiment in vacuum?\n\n# ### Exercise 2 (10 pt), setting up forces, Newton's second law\n# \n# Useful material here to read is\n# 1. Taylor chapters 1.3 and 1.4 and\n# \n# 2. Malthe-Sørenssen chapters 5.1, 5.2 and 5.3\n# \n# A person jumps from an airplane, falling freely for several seconds before the person pulls the cord of her parachute and the parachute unfolds.\n# * 2a (3pt)  Identify the forces acting on the parachuter and draw a free-body diagram of the parachuter before the person has pulled the cord.\n# \n# * 2b (3pt)  Identify the forces acting on the parachuter and draw a free-body diagram of the parachuter after the person has pulled the cord.\n# \n# * 2c (4pt)  Sketch the net force acting on the parachuter as a function of time, F(t).\n\n# ### Exercise 3 (10 pt), Space shuttle with air resistance\n# \n# Useful material here to read is\n# 1. Malthe-Sørenssen chapters 5.1, 5.2 and 5.3\n# \n# During lift-off of the space shuttle the engines provide a force of $35\\times 10^{6}$ N. The mass of the shuttle is approximately\n# $2\\times 10^6$ kg.\n# * 3a (3pt) Draw a free-body diagram of the space shuttle immediately after lift-off.\n# \n# * 3b (3pt)  Find an expression for the acceleration of the space shuttle immediately after lift-off.\n# \n# Let us assume that the force from the engines is constant, and that the mass of the\n# space shuttle does not change significantly over the first 20 s.\n# * 3c (4pt) Find the velocity and position of the space shuttle after 20 s if you ignore air resistance.\n\n# ### Exercise 4 (15 pt), now hitting a golf ball\n# \n# Useful material here to read is\n# 1. Taylor chapters 1.3-1.6 and\n# \n# 2. Malthe-Sørenssen chapter 6.3-6.4 and 7.1-7.3\n# \n# **Taylor exercise 1.35**. The formulae you obtain here will be useful for the numerical exercises below (see exercise 6 below).\n\n# ### Exercise 5 (15 pt), hitting a puck instead\n# \n# Taylor exercise 1.38.\n\n# ### Exercise 6 (40pt), Numerical elements, moving to more than one dimension\n# \n# **This exercise should be handed in as a jupyter-notebook** at D2L. Remember to write your name(s). \n# \n# Last week we:\n# 1. Analytically mapped 1D motion over some time\n# \n# 2. Gained practice with functions\n# \n# 3. Reviewed vectors and matrices in Python\n# \n# This week we will:\n# 1. Practice using Python syntax and variable manipulation\n# \n# 2. Utilize analytical solutions to create more refined functions\n# \n# 3. Work in two, three or even higher dimensions\n# \n# This material will then serve as background for the numerical part of homework 3. The first part is a simple warm-up, with hints and suggestions you can use for the code to write below.\n\n# In[1]:\n\n\nget_ipython().run_line_magic('matplotlib', 'inline')\n\n# As usual, here are some useful packages we will be using. Feel free to use more and experiment as you wish.\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits import mplot3d\nget_ipython().run_line_magic('matplotlib', 'inline')\n\n\n# In class (the falling baseball example) we used an  analytical expression for the height of a falling ball.\n# In the first homework we used instead the position from experiment (Usain Bolt's 100m record run) and stored this\n# information with one-dimensional arrays in Python.\n# \n# Let us get some practice with this. The cell below creates two arrays,\n# one containing the times to be analyzed and the other containing the $x$\n# and $y$ components of the position vector at each point in time.  This is a two-dimensional object. The\n# second array is initially empty. Then we define  the initial\n# position to be $x=2$ and $y=1$. Take a look at the code and comments\n# to get an understanding of what is happening. Feel free to play around with it.\n\n# In[2]:\n\n\ntf = 4 #length of value to be analyzed\ndt = .001 # step sizes\nt = np.arange(0.0,tf,dt) # Creates an evenly spaced time array going from 0 to 3.999, with step sizes .001\np = np.zeros((len(t), 2)) # Creates an empty array of [x,y] arrays (our vectors). Array size is same as the one for time.\np[0] = [2.0,1.0] # This sets the inital position to be x = 2 and y = 1\n\n\n# Below we are printing specific values of our array to see what is being\n# stored where. The first number in the array $r[]$ represents which array\n# iteration we are looking at, while the number after the  represents\n# which listed number in the array iteration we are getting back.\n\n# In[3]:\n\n\nprint(p[0]) # Prints the first array\nprint(p[0,:]) # Same as above, these commands are interchangeable\n\n\n# In[4]:\n\n\nprint(p[3999]) # Prints the 4000th array\n\n\n# In[5]:\n\n\nprint(p[0,0]) # Prints the first value of the first array\n\n\n# In[6]:\n\n\nprint(p[0,1]) # Prints the second value of first array\nprint(p[:,0]) # Prints the first value of all the arrays\n\n\n# Then try running this cell. Notice how it gives an error since we did not implement a third dimension into our arrays\n\n# In[7]:\n\n\nprint(p[:,2])\n\n\n# In the cell below we want to manipulate the arrays.\n# In this example we make each vector's $x$ component valued the same as their respective vector's position in the iteration and the $y$ value will be twice that value, except for  the first vector, which we have already set. \n# That is we have $p[0] = [2,1], p[1] = [1,2], p[2] = [2,4], p[3] = [3,6], ...$\n# \n# Here we set up an array for $x$ and $y$ values.\n\n# In[8]:\n\n\nfor i in range(1,3999):\n    p[i] = [i,2*i]\n# Checker cell to make sure your code is performing correctly\nc = 0\nfor i in range(0,3999):\n    if i == 0:\n        if p[i,0] != 2.0:\n            c += 1\n        if p[i,1] != 1.0:\n            c += 1\n    else:\n        if p[i,0] != 1.0*i:\n            c += 1\n        if p[i,1] != 2.0*i:\n            c += 1\n\nif c == 0:\n    print(\"Success!\")\nelse:\n    print(\"There is an error in your code\")\n\n\n# You could also think of an alternative way of storing the above information. Feel free to explore how to store\n# multidimensional objects. \n# \n# Last week we studied Usain Bolt's 100m run and in class we studied a falling baseball. We made basic plots of the baseball\n# moving in one dimension. This week we will be working with a three-dimensional variant. This will be useful for our next homeworks and numerical projects. \n# \n# Assume we have a soccer ball moving in three dimensions with the following trajectory:\n# \n# 1. $x(t) = 10t\\cos{45^{\\circ}} $\n# \n# 2. $y(t) = 10t\\sin{45^{\\circ}} $\n# \n# 3. $z(t) = 10t - \\dfrac{9.81}{2}t^2$\n# \n# Now let us create a three-dimensional (3D) plot using these equations. In the cell below\n# we write the equations into their respective labels. We fix a final time in the code below.\n# \n# Important Concept: Numpy comes with many mathematical packages, some\n# of them being the trigonometric functions sine, cosine, tangent. We\n# are going to utilize these this week. Additionally, these functions\n# work with radians, so we will also be using a function from Numpy that\n# converts degrees to radians.\n\n# In[9]:\n\n\ntf = 2.04  # The final time to be evaluated\ndt = 0.1  # The time step size\nt = np.arange(0,tf,dt) # The time array\ntheta_deg = 45 # Degrees\ntheta_rad = np.radians(theta_deg) # Converts degrees to their radian counterparts\nx = 10*t*np.cos(theta_rad) # Equation for our x component, utilizing np.cos() and our calculated radians\ny = 10*t*np.sin(theta_rad) # Put the y equation here\nz = 10*t-9.81/2*t**2# Put the z equation here\n\n\n# Then we plot it\n\n# In[10]:\n\n\n## Once you have entered the proper equations in the cell above, run this cell to plot in 3D\nfig = plt.axes(projection='3d')\nfig.set_xlabel('x')\nfig.set_ylabel('y')\nfig.set_zlabel('z')\nfig.scatter(x,y,z)\n\n\n# * 6a (8pt) How would you express $x(t)$, $y(t)$, $z(t)$ for this problem as a single vector, $\\boldsymbol{r}(t)$?\n# \n# Then run the code and plot using the array $r$\n\n# In[11]:\n\n\n## Run this code to plot using our r array \nfig = plt.axes(projection='3d')\nfig.set_xlabel('x')\nfig.set_ylabel('y')\nfig.set_zlabel('z')\nfig.scatter(r[0],r[1],r[2])\n\n\n# * 6b (8pt) What do you think the benefits and/or disadvantages are from expressing our three equations as a single array/vector? This can be both from a computational and physics stand point. Use the **Numpy** package to also print the maximum $x$, $y$ and $z$ components from $\\boldsymbol{r}$.\n# \n# Complete Exercise 4 above (Taylor exercise 1.35) before moving further. (Recall that the golf ball was hit due east at an angle $\\theta$ with respect to the horizontal, and the coordinate directions are $x$ measured east, $y$ north, and $z$ vertically up.)\n# \n# * 6c (8pt) What is the analytical solution for our theoretical golf ball's position $\\boldsymbol{r}(t)$ over time from Exercise 4?  Also what is the formula for the time $t_f$ when the golf ball hits the ground? Use this to develop a program with a function called for example Golfball that utilizes our analytical solutions. This program should take in an initial velocity and the angle $\\theta$ that the golfball was hit with in degrees. It should also produce  a 3D graph of the motion. You need also to find the maximum values for $x$, $y$ and $z$.\n# \n# * 6d (8pt) Given initial values of $v_i = 90 m/s$, $\\theta = 30^{\\circ}$, what would our maximum x, y and z components be? \n# \n# * 6e (8pt) Given initial values of $v_i = 45 m/s$, $\\theta = 45^{\\circ}$, what would our maximum x, y and z components be?\n", "meta": {"hexsha": "34d539caf9ea2e90b18237dc71c7b03b08395c12", "size": 11057, "ext": "py", "lang": "Python", "max_stars_repo_path": "doc/LectureNotes/_build/jupyter_execute/hw2.py", "max_stars_repo_name": "Shield94/Physics321", "max_stars_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "doc/LectureNotes/_build/jupyter_execute/hw2.py", "max_issues_repo_name": "Shield94/Physics321", "max_issues_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "doc/LectureNotes/_build/jupyter_execute/hw2.py", "max_forks_repo_name": "Shield94/Physics321", "max_forks_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.9518518519, "max_line_length": 554, "alphanum_fraction": 0.710771457, "include": true, "reason": "import numpy", "num_tokens": 3106, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.28457600421652673, "lm_q2_score": 0.25091279808829703, "lm_q1q2_score": 0.07140376148675574}}
{"text": "r\"\"\"\nElements of posets, lattices, semilattices, etc.\n\"\"\"\n#*****************************************************************************\n#       Copyright (C) 2008 Peter Jipsen <jipsen@chapman.edu>,\n#                          Franco Saliola <saliola@gmail.com>\n#\n#  Distributed under the terms of the GNU General Public License (GPL)\n#\n#    This code is distributed in the hope that it will be useful,\n#    but WITHOUT ANY WARRANTY; without even the implied warranty of\n#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n#    General Public License for more details.\n#\n#  The full text of the GPL is available at:\n#\n#                  http://www.gnu.org/licenses/\n#*****************************************************************************\nfrom sage.structure.element import Element\nfrom sage.structure.element import have_same_parent\n\n\nclass PosetElement(Element):\n\n    def __init__(self, poset, element, vertex):\n        r\"\"\"\n        Establish the parent-child relationship between ``poset``\n        and ``element``, where ``element`` is associated to the\n        vertex ``vertex`` of the Hasse diagram of the poset.\n\n        INPUT:\n\n        - ``poset`` -- a poset object\n\n        - ``element`` -- any object\n\n        - ``vertex`` -- a vertex of the Hasse diagram of the poset\n\n        TESTS::\n\n            sage: from sage.combinat.posets.elements import PosetElement\n            sage: P = Poset([[1,2],[4],[3],[4],[]], facade = False)\n            sage: e = P(0)\n            sage: e.parent() is P\n            True\n            sage: TestSuite(e).run()\n        \"\"\"\n        Element.__init__(self, poset)\n        if isinstance(element, self.parent().element_class):\n            self.element = element.element\n        else:\n            self.element = element\n        self.vertex = vertex\n\n    def __hash__(self):\n        r\"\"\"\n        TESTS::\n\n            sage: P = Poset([[1,2],[4],[3],[4],[]], facade = False)\n            sage: e = P(0)\n            sage: hash(e)\n            0\n        \"\"\"\n        return hash(self.element)\n\n    def _repr_(self):\n        \"\"\"\n        TESTS::\n\n            sage: Poset([[1,2],[4],[3],[4],[]], facade = False)(0)._repr_()\n            '0'\n        \"\"\"\n        return \"%s\" % str(self.element)\n\n    def _latex_(self):\n        r\"\"\"\n        Return the latex code of the poset element.\n\n        EXAMPLES::\n\n            sage: m = matrix(2,[1,2,3,4])\n            sage: m.set_immutable()\n            sage: P = Poset(([m],[]), facade = False)\n            sage: [e] = P\n            sage: type(e)\n            <class 'sage.combinat.posets.posets.FinitePoset_with_category.element_class'>\n            sage: latex(e)                 #indirect doctest\n            \\left(\\begin{array}{rr}\n            1 & 2 \\\\\n            3 & 4\n            \\end{array}\\right)\n        \"\"\"\n        from sage.misc.latex import latex\n        return latex(self.element)\n\n    def __eq__(self, other):\n        \"\"\"\n        TESTS::\n\n            sage: P = Poset([[\"a\",\"b\"],[\"d\"],[\"c\"],[\"d\"],[]], facade = False)\n            sage: Q = Poset([[\"a\",\"b\"],[\"d\"],[\"c\"],[],[]], facade = False)\n            sage: P(0).__eq__(P(4))\n            False\n            sage: from sage.combinat.posets.elements import PosetElement\n            sage: PosetElement(P,0,\"c\") == PosetElement(P,0,\"c\")\n            True\n            sage: PosetElement(P,0,\"c\") == PosetElement(Q,0,\"c\")\n            False\n            sage: PosetElement(P,0,\"b\") == PosetElement(P,0,\"c\")\n            False\n\n        .. warning:: as an optimization, this only compares the parent\n           and vertex, using the invariant that, in a proper poset\n           element, ``self.element == other.element`` if and only\n           ``self.vertex == other.vertex``::\n\n            sage: PosetElement(P,1,\"c\") == PosetElement(P,0,\"c\")\n            True\n\n        Test that :trac:`12351` is fixed::\n\n            sage: P(0) == int(0)\n            False\n        \"\"\"\n        # This should instead exploit unique representation, using\n        # self is other, or best inherit __eq__ from there. But there\n        # are issues around pickling and rich comparison functions.\n        return have_same_parent(self, other) \\\n            and self.vertex == other.vertex\n\n    def __ne__(self, other):\n        r\"\"\"\n        TESTS::\n\n            sage: P = Poset([[1,2],[4],[3],[4],[]])\n            sage: P = Poset([[\"a\",\"b\"],[\"d\"],[\"c\"],[\"d\"],[]])\n            sage: P(0).__ne__(P(4))\n            True\n            sage: from sage.combinat.posets.elements import PosetElement\n            sage: PosetElement(P,0,\"c\") != PosetElement(P,0,\"c\")\n            False\n            sage: PosetElement(P,0,\"b\") != PosetElement(P,0,\"c\")\n            True\n\n        For this one, see comment in :meth:`__eq__`::\n\n            sage: PosetElement(P,1,\"c\") != PosetElement(P,0,\"c\")\n            False\n        \"\"\"\n        return not self == other\n\n    def _cmp(self, other):\n        \"\"\"\n        TESTS::\n\n            sage: P = Poset([[1,2],[4],[3],[4],[]], facade = False)\n            sage: P(0)._cmp(P(4))\n            -1\n            sage: P(4)._cmp(P(0))\n            1\n            sage: P(0)._cmp(P(0))\n            0\n            sage: P(1)._cmp(P(2))\n\n        \"\"\"\n        return self.parent().compare_elements(self, other)\n\n    def __lt__(self, other):\n        \"\"\"\n        TESTS\n\n        ::\n\n            sage: dag = DiGraph({0:[2,3], 1:[3,4], 2:[5], 3:[5], 4:[5]})\n            sage: P = Poset(dag, facade = False)\n            sage: P(0) < P(1)\n            False\n            sage: P(4) < P(1)\n            False\n            sage: P(0) < P(0)\n            False\n        \"\"\"\n        return self._cmp(other) == -1 or False\n\n    def __le__(self, other):\n        \"\"\"\n        TESTS\n\n        ::\n\n            sage: dag = DiGraph({0:[2,3], 1:[3,4], 2:[5], 3:[5], 4:[5]})\n            sage: P = Poset(dag, facade = False)\n            sage: P(1) <= P(0)\n            False\n            sage: P(0) <= P(1)\n            False\n            sage: P(0) <= P(3)\n            True\n            sage: P(0) <= P(0)\n            True\n        \"\"\"\n        return self == other or self._cmp(other) == -1 or False\n\n    def __gt__(self, other):\n        \"\"\"\n        TESTS\n\n        ::\n\n            sage: dag = DiGraph({0:[2,3], 1:[3,4], 2:[5], 3:[5], 4:[5]})\n            sage: P = Poset(dag)\n            sage: P(0).__gt__(P(5))\n            False\n            sage: P(5).__gt__(P(0))\n            True\n            sage: P(0).__gt__(P(0))\n            False\n        \"\"\"\n        return self._cmp(other) == 1 or False\n\n    def __ge__(self, other):\n        \"\"\"\n        TESTS\n\n        ::\n\n            sage: dag = DiGraph({0:[2,3], 1:[3,4], 2:[5], 3:[5], 4:[5]})\n            sage: P = Poset(dag)\n            sage: P(0).__ge__(P(5))\n            False\n            sage: P(5).__ge__(P(0))\n            True\n            sage: P(0).__ge__(P(0))\n            True\n        \"\"\"\n        return self == other or self._cmp(other) == 1 or False\n\n\nclass MeetSemilatticeElement(PosetElement):\n    def __mul__(self, other):\n        r\"\"\"\n        Return the meet of ``self`` and ``other`` in the lattice.\n\n        EXAMPLES::\n\n            sage: D = posets.DiamondPoset(5,facade=False)\n            sage: D(1) * D(2)\n            0\n            sage: D(1) * D(1)\n            1\n            sage: D(1) * D(0)\n            0\n            sage: D(1) * D(4)\n            1\n        \"\"\"\n        return self.parent().meet(self, other)\n\n\nclass JoinSemilatticeElement(PosetElement):\n    def __add__(self, other):\n        r\"\"\"\n        Return the join of ``self`` and ``other`` in the lattice.\n\n        EXAMPLES::\n\n            sage: D = posets.DiamondPoset(5,facade=False)\n            sage: D(1) + D(2)\n            4\n            sage: D(1) + D(1)\n            1\n            sage: D(1) + D(4)\n            4\n            sage: D(1) + D(0)\n            1\n        \"\"\"\n        return self.parent().join(self, other)\n\n\nclass LatticePosetElement(MeetSemilatticeElement, JoinSemilatticeElement):\n    pass\n", "meta": {"hexsha": "fc0c98e118d92145677e23f936dc46ea7f3f374e", "size": 7912, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/combinat/posets/elements.py", "max_stars_repo_name": "bopopescu/sage", "max_stars_repo_head_hexsha": "2d495be78e0bdc7a0a635454290b27bb4f5f70f0", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2020-07-17T04:49:44.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-29T06:33:51.000Z", "max_issues_repo_path": "src/sage/combinat/posets/elements.py", "max_issues_repo_name": "Ivo-Maffei/sage", "max_issues_repo_head_hexsha": "467fbc70a08b552b3de33d9065204ee9cbfb02c7", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-10-30T13:40:20.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-23T12:13:30.000Z", "max_forks_repo_path": "src/sage/combinat/posets/elements.py", "max_forks_repo_name": "dimpase/sage", "max_forks_repo_head_hexsha": "468f23815ade42a2192b0a9cd378de8fdc594dcd", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2021-11-08T10:01:59.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T11:25:52.000Z", "avg_line_length": 28.1565836299, "max_line_length": 89, "alphanum_fraction": 0.4634732053, "include": true, "reason": "from sage", "num_tokens": 2142, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43014734858584286, "lm_q2_score": 0.16451646494473965, "lm_q1q2_score": 0.07076632119469552}}
{"text": "\"\"\"\n        Assignment-2\n        Name - Gajraj Singh Chouhan\n        Roll No - B19130\n        Branch - DSE\n        Mobile No - +91-9351159849\n\"\"\"\n\nimport pandas as pd\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfrom functions import properties, plot_rmse\n\n# imports\n\ndata = pd.read_csv('pima_indians_diabetes_miss.csv')\noriginal_data = pd.read_csv('pima_indians_diabetes_original.csv')\n\n# Question 1\n\nmissing_val = data.isna().sum()\n# We can count the missing values by using isna(), adding all the cells in a column which would a NaN value (isna() would give each cell 1 or 0 whether it is or is-not a NaN value).\nmissing_val.plot.bar(rot=0)\n# plotting the missing values.\n# adding the labels and title.\nplt.title(\"Missing Values in the Attributes\")\nplt.xlabel(\"Attributes\")\nplt.ylabel(\"Missing Values\")\nplt.savefig(\"Q1-Barplot.png\")\nplt.close()\n\n# Question 2a\nprint('Question 2a', end='\\n\\n')\n\ncol = data.shape[1] # number of columns\nto_drop = 3 # inverse of 1/3rd rows to drop\nfiltered = data.isna().sum(axis=1)\n# finding how many NaN values are in each row by summing the boolean values for each row. (using axis=1 will do sum of each row)\n# Now we have a dataframe consisting of number of NaN values in that row \n\nfiltered = filtered[(filtered * to_drop) >= col]\n# We can filter the rows to drop, by using the condition that number of NaN values must be greater or equal to 1/3rd of no of columns.\n# This will give us True or False Boolean Value if that row is to be dropped or not.\n\nprint(f\"Total number of tuples deleted = {filtered.size}\")\n\nfiltered = filtered.index\ndata = data.drop(filtered, axis=0)\n# Now we can drop the rows in the original DataFrame using their indexes we got in the previous step.\n\nprint(f\"Indices of rows dropped (0-based): \")\nprint(filtered.to_list());print()\n\n# Question 2b\nprint('Question 2b', end='\\n\\n')\n\nfiltered = data[data['class'].isna()]\n# rows whose 'class' attribute is NaN using conditional filtering\nfiltered = filtered.index\n# getting index of rows which we will delete\n\nprint(f\"Total number of tuples deleted = {filtered.size}\")\n\ndata = data.drop(filtered, axis=0) # remove the rows\n\nprint(f\"Indices of rows dropped (0-based): \")\nprint(filtered.to_list());print()\n\n# Question 3\nprint('Question 3', end='\\n\\n')\n\ncount_of_NaN = data.isna().sum()\n# again we can use isna() for number of null values.\n\nprint(\"Number of missing values in each attributes: \")\nprint(count_of_NaN.to_frame().T)\n# printing number of missing value per column\n# ignore the first 0, it just the first row number as I am displaying the Series in horizontal way.\nprint(f\"Total number of missing values in the dataFrame : {count_of_NaN.sum()}\");print()\n\n# Question 4a\nprint('Question 4a', end='\\n\\n')\ncolumn_mean = data.mean()\ndata_withmean = data.fillna(column_mean)\n# fillna() will fill the NaN values for each attribute by the mean of that column\n\nprint('RMSE of Original and Mean Filled data')\nplot_rmse(data_withmean, original_data, np.where(pd.isnull(data)), count_of_NaN);print()\n\n# plotting the rmse after replacing the nan values.\nplt.title(\"RMSE of original and mean filled data\")\nplt.savefig(\"Q4-MeanFilled.png\") \nplt.close()\n\n# Question 4b\nprint('Question 4b', end='\\n\\n')\n\ndata_with_interpolate = data.interpolate()\n# by default each column will be filled with data interpolated with linear method.\n\nprint('RMSE of Original and interpolated data')\nplot_rmse(data_with_interpolate, original_data, np.where(pd.isnull(data)), count_of_NaN);print()\n\nplt.title(\"RMSE of original and interpolated data\")\nplt.savefig(\"Q4-Interpolated.png\")\nplt.close()\n\n# Question 4\nprint('Question 4 (comparing the filled data and original) : ', end='\\n\\n')\n\n# Comparing the properties (mean, median, mode, standard-dev...) of the \n# original data and after we filled the values in 4a and 4b.\nprint('Original Data : ')\nprint(properties(original_data).to_string())\nprint('\\nAfter filling data with mean : ')\nprint(properties(data_withmean).to_string())\nprint('\\nAfter interpolating the data : ')\nprint(properties(data_with_interpolate).to_string());print()\n\n\n# Question 5\nprint('Question 5 (Outliers)', end='\\n\\n')\n    \n\ndata_with_interpolate = data.interpolate()\ncolumns = [\"Age\", \"BMI\"]\nquartiles = data_with_interpolate.quantile([0.25, 0.5, 0.75]).loc[:, columns]\n# quantile() will give the required quartiles (0.25, 0.5, 0.75) for required columns\ndata.loc[:, columns].plot.box()\nplt.title(\"Box-Plot of data before replacing outliers with median\")\nplt.savefig(\"Q5-before-BoxPlot.png\")\nplt.close()\n\nfor col in columns:\n    q1, median, q3 = quartiles.loc[:, col].to_list()\n    # quartiles for one column\n    print(f\"Column : {col}\")\n    check_outlier = lambda num : (q1 - (1.5 * (q3 - q1))) < num < (q3 + (1.5 * (q3 - q1)))\n    # this will return boolean value whether a number (\"num\") would be outlier according to the quartiles.\n    for ind, x in enumerate(data_with_interpolate.loc[:, col]):\n        # iterating over the column and checking if it's a outlier.\n        if not check_outlier(x):\n            # if it is a outlier\n            data.loc[data_with_interpolate.index[ind], col] = median\n            # we can change value of a cell to the median of that column from the column name and row index.\n            # data_with_interpolate.index[ind] - row index\n            print(x, end=' ')\n    print()\n\ndata.loc[:, columns].plot.box()\nplt.title(\"Box-Plot of data after replacing outliers with median\")\nplt.savefig(\"Q5-after-BoxPlot.png\")\nplt.close()\n\n\nprint('properties after replacing with median : ')\nprint(properties(data.loc[:, columns]));print()", "meta": {"hexsha": "e30defeeb8e93dea8bc80f9619baf3e4cc5052d4", "size": 5575, "ext": "py", "lang": "Python", "max_stars_repo_path": "Lab Assignment 2/lab2.py", "max_stars_repo_name": "gajrajgchouhan/DS3-Assignments", "max_stars_repo_head_hexsha": "b43937967f80eb3d6d9ebfc6001e0db8da3a2cf8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lab Assignment 2/lab2.py", "max_issues_repo_name": "gajrajgchouhan/DS3-Assignments", "max_issues_repo_head_hexsha": "b43937967f80eb3d6d9ebfc6001e0db8da3a2cf8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lab Assignment 2/lab2.py", "max_forks_repo_name": "gajrajgchouhan/DS3-Assignments", "max_forks_repo_head_hexsha": "b43937967f80eb3d6d9ebfc6001e0db8da3a2cf8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.5095541401, "max_line_length": 181, "alphanum_fraction": 0.718206278, "include": true, "reason": "import numpy", "num_tokens": 1417, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4649015713733884, "lm_q2_score": 0.15203224546424315, "lm_q1q2_score": 0.07068002981575135}}
{"text": "\"\"\"\nModule file containing functions that allow to reproduce FIG. 1 of the article\n\n    Interaction of \"Solitons\" in a Collisionless Plasma and the Recurrence of Initial States,\n    N. J. Zabusky and M. D. Kruskal,\n    Phys. Rev. Lett. 15, 240 (1965)\n\nThis module was prepared as a part of the scientific short course\n\n  A brief guide to publication-ready scientific figures using Python's matplotlib\n\nheld during the 2020 seminar week of the Ultrafast Laser Laboratory\nat Institute of Quantum Optics at Leibniz University Hannover.\n\nAuthor: O. Melchert\nDate: 2020-09-08\n\"\"\"\nimport numpy as np\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nfrom matplotlib.gridspec import GridSpec\n\n__author__ = 'Oliver Melchert'\n__date__ = '2020-09-09'\n\ndef fetch_data(path):\n    \"\"\"fetch data\n\n    Reads in data from file in numpy npz-format\n\n    Args:\n      path (str): path to npz-file\n\n    Returns: (x, t, uxt)\n      x (1D array): x samples\n      t (1D array): t samples\n      uxt (2D array): wave profile u(x,t)\n    \"\"\"\n    dat = np.load(path)\n    return dat['x'], dat['t'], dat['uxt']\n\n\ndef set_style():\n    \"\"\"set figure style\n\n    Function that customizes the default style to be conform with the Physical\n    Review style and notation guide [1]. For instructions on how to set the\n    default style using style sheets see [2].\n\n    Notes:\n    - main font size is chosen as 8pt, matching the fontsize of figure captions\n    - fontsize of legends and auxiliary text labels are set to 6pt, exceeding\n      the minimally required pointsize of 4.25 pt. (1.5 mm)\n    - default rc (rc = \"run commands\", i.e. startup information) settings are\n      changed dynamically\n    - the custom font-scheme 'type2' depends on your latex installation and\n      is not guaranteed to run on your specific system\n\n    Refs:\n      [1] https://journals.aps.org/prl/authors\n      [2] https://matplotlib.org/3.3.1/tutorials/introductory/customizing.html\n    \"\"\"\n\n    fig_width_1col = 3.4        # figure width in inch\n    fig_width_2col = 7.0        # figure width in inch\n    fig_aspect_ratio = 0.66     # width to height aspect ratio\n    font_size = 8               # font size in pt\n    font_size_small = 6         # font size in pt\n    font_scheme = 'type2'       # options: \n                                #   None    - default matplotlib fonts\n                                #   'type1' - text: Helvetica, math: Computer modern\n                                #   'type2' - text: Helvetica, math: Helvetica \n\n    mpl.rcParams['figure.figsize'] = fig_width_1col, fig_aspect_ratio*fig_width_1col\n    mpl.rcParams['axes.labelsize'] = font_size\n    mpl.rcParams['font.size'] = font_size\n    mpl.rcParams['legend.fontsize'] = font_size_small\n    mpl.rcParams['xtick.labelsize'] = font_size\n    mpl.rcParams['ytick.labelsize'] = font_size\n    mpl.rcParams['xtick.direction'] = 'out'\n    mpl.rcParams['ytick.direction'] = 'out'\n    mpl.rcParams['lines.linewidth'] = 1.0\n    mpl.rcParams['axes.linewidth'] =  0.5\n\n    if font_scheme == 'type1':\n        mpl.rcParams['text.usetex'] = True\n        mpl.rcParams['font.family'] = 'sans-serif'\n        mpl.rcParams['font.sans-serif'] = 'Helvetica'\n        mpl.rcParams['mathtext.fontset'] = 'cm'\n\n    if font_scheme == 'type2':\n        mpl.rcParams['text.usetex'] = True\n        mpl.rcParams['text.latex.preamble'] = [\n           r'\\usepackage{siunitx}',\n           r'\\sisetup{detect-all}',\n           r'\\usepackage{helvet}',\n           r'\\usepackage{sansmath}',\n           r'\\sansmath'\n        ]\n\n\ndef set_circle(ax, x0, y0, label):\n    \"\"\"set circle\n\n    Function that generates a circle with text-label at its center.\n    For more options on scatter plots, see [1], for more options on\n    setting text, see [2]\n\n    Refs:\n      [1] https://matplotlib.org/3.3.1/api/_as_gen/matplotlib.pyplot.scatter.html\n      [2] https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.text.html\n\n    Args:\n      ax (object): figure part for which the labeled circle is intended\n      x0 (float): x-position for center of circle\n      y0 (float): y-position for center of circle\n      label (str): text that should be displayed within circle\n    \"\"\"\n    # -- scatter plot consisting of a single object\n    ax.scatter(x0, y0, s=50, linewidth=0.75, facecolors='none', edgecolor='black', zorder=10)\n    # -- place text at the center of the scatter plot object\n    ax.text(x0, y0, label, backgroundcolor='none', ha='center', va='center', color='black', zorder=10, fontsize=6)\n\n\ndef set_legend(ax, lines):\n    \"\"\"set legend\n\n    Function generating a custom legend, see [1] for more options\n\n    Refs:\n      [1] https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.legend.html\n\n    Args:\n      ax (object): figure part for which the legend is intended\n      lines (list): list of  Line2D objects\n    \"\"\"\n    # -- extract labels from lines\n    labels = [x.get_label() for x in lines]\n    # -- customize legend \n    ax.legend(lines,                # list of Line2D objects\n              labels,               # labels \n              title = '',           # title shown on top of legend \n              loc = 0,              # location of the legend\n              ncol = 1,             # number of columns\n              labelspacing = 0.3,   # vertical space between handles in font-size units\n              borderpad = 0.3,      # distance to legend border in font-size units\n              handletextpad = 0.6,  # distance between handle and label in font-size units\n              handlelength = 2.0,   # length of handle in font-size units\n              frameon = False       # remove background patch\n              )\n\n\ndef set_grid(ax):\n    \"\"\"set grid\n\n    Function generating a custom grid, see [1] for more options\n\n    Refs:\n      [1] https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.grid.html\n\n    Args:\n      ax (object): figure part for which the grid is intended\n    \"\"\"\n    #ax.set_facecolor('lightgray')\n    ax.grid(which = 'major',        # grid lines at major ticks only\n            linestyle = '-',        # solid line\n            linewidth = 0.5,        # width of gridlines\n            color = 'lightgray',    # color of gridlines\n            zorder = 0\n            )\n\n\ndef save_figure(fig_format = None, fig_name = 'test'):\n    \"\"\" save figure\n\n    Function that saves figure or shows interactive plot\n\n    Note:\n    - if no valid option is provided, an interactive plot is shown\n\n    Args:\n      fig_format (str): format to save figure in (options: png, pdf, svg)\n      fig_name (str): name for figure (default: 'test')\n    \"\"\"\n    if fig_format == 'png':\n        plt.savefig(fig_name+'.png', format='png', dpi=600)\n    elif fig_format == 'pdf':\n        plt.savefig(fig_name+'.pdf', format='pdf', dpi=600)\n    elif fig_format == 'svg':\n        plt.savefig(fig_name+'.svg', format='svg')\n    else:\n        plt.show()\n\n\ndef generate_figure(x, t, uxt, fig_format=None, fig_name='fig01'):\n    \"\"\"generate figure\n\n    Function generating a figure reproducing FIG. 1 of [1].\n\n    Refs:\n      [1] Interaction of \"Solitons\" in a Collisionless Plasma and the Recurrence of Initial States,\n          N. J. Zabusky and M. D. Kruskal,\n          Phys. Rev. Lett. 15, 240 (1965)\n\n    Args:\n      x (1D array): x samples\n      t (1D array): t samples\n      uxt (2D array): wave profile u(x,t)\n      fig_format (str): format for output figure\n                        (choices: png, pdf, svg; default: interactive figure)\n      fig_name (str): name for output figure wihtout suffix (default='fig01')\n    \"\"\"\n\n    # (1) SET A STYLE THAT FITS THE TARGET JOURNAL\n    set_style()\n\n    # (2) SET FIGURE LAYOUT\n    fig = plt.figure()\n    plt.subplots_adjust(left = 0.12,    # pos. of subplots left border\n                        bottom = 0.16,  # pos. of subplots bottom border \n                        right = 0.97,   # pos. of subplots right border\n                        top = 0.98      # pos. of subplots top border\n                        )\n    gs00 = GridSpec(nrows = 1, ncols = 1)   # set geometry of subplot grid\n    ax01 = fig.add_subplot(gs00[:,:])       # add subplot\n\n\n    # (3) SET AXES CONTENTS\n    # -- custom constants and local functions\n    tB = 1./np.pi                                   # breakdown time\n    _ux = lambda t0: uxt[np.argmin(np.abs(t-t0))]   # wave form for array index closest to t0 \n\n    # -- plot real-vaued field at selected times \n    l1 = ax01.plot(x, _ux(0.0),    color='blue',  dashes=[1,1], zorder=100, label=r'$t=0$')\n    l2 = ax01.plot(x, _ux(1.0*tB), color='green', dashes=[3,1], zorder=101, label=r'$t=t_{\\mathrm{B}}$')\n    l3 = ax01.plot(x, _ux(3.6*tB), color='black', zorder=102, label=r'$t=3.6\\,t_{\\mathrm{B}}$')\n\n    # -- add legend \n    set_legend(ax01, l1 + l2 + l3)\n\n    # -- set data curve labels\n    ax01.text(1.27, -0.9,               # x,y pos. in data coordinates  \n                r'A',                   # text label    \n                color='blue',           # text color\n                backgroundcolor='none', # backgroundcolor\n                ha='left',              # horizontal alignment\n                va='bottom',            # vertical alignment\n                zorder=10               # layering order in figure\n                )\n    ax01.text(0.60, -0.9, r'B', color='green', backgroundcolor='none',\n                    ha='left', va='bottom', zorder=10)\n    ax01.text(1.75, -0.9, r'C', color='black', backgroundcolor='none',\n                    ha='left', va='bottom', zorder=10)\n\n    # -- set auxiliary dash-dotted lines\n    _f = lambda x: -1.5+1.5*np.where(x>0.8, x, x+2.)\n    ax01.plot(x[x<0.75], _f(x[x<0.75]), color='black',\n                    dashes = [15,1,2,1,2,1], linewidth=0.75)\n    ax01.plot(x[x>0.80], _f(x[x>0.80]), color='black',\n                    dashes = [15,1,2,1,2,1], linewidth=0.75)\n\n    # -- set circles with labels\n    for  idx, x0 in enumerate([0.643, 0.362, 0.098, 0.920, 1.14, 1.37, 1.6, 1.845]):\n        set_circle(ax01, x0, _f(x0) + 0.2, '$%d$'%(idx+1))\n\n    # (4) SET AXIS DETAILS\n    # -- customize x-axis\n    x_lim = (0, 2)\n    x_ticks = (0., 0.5, 1.0, 1.5, 2.0)\n    # -- major ticks\n    ax01.tick_params(\n        axis = 'x',         # axis for which to set ticks \n        direction = 'out',  # place ticks outside\n        length = 3.5,       # tick length in pts.\n        pad = 2,            # tick to label distance in pts.\n        top=False           # no ticks on top spine\n        )\n    ax01.set_xlim(x_lim)\n    ax01.set_xticks(x_ticks)\n    # -- minor ticks\n    ax01.tick_params(\n        axis = 'x',         # axis for which to set ticks\n        which = 'minor',    # address minor ticks\n        length = 2.         # tick length in pts.\n        )\n    ax01.set_xticks(\n        np.linspace(x_lim[0],x_lim[1], int((x_lim[1]-x_lim[0])/0.1), endpoint=False),\n        minor=True\n        )\n    # -- label\n    ax01.set_xlabel(r'Normalized distance $x$')\n\n    # -- customize y-axis\n    y_lim = (-1., 3.)\n    y_ticks = (-1., 0., 1., 2., 3.)\n    # -- major ticks\n    ax01.tick_params(axis='y', direction='out', length=3.5, pad=2, right=False)\n    ax01.set_ylim(y_lim)\n    ax01.set_yticks(y_ticks)\n    # -- minor ticks\n    ax01.tick_params(axis='y', which='minor', length=2.)\n    ax01.set_yticks(np.linspace(y_lim[0], y_lim[1], int((y_lim[1]-y_lim[0])/0.2), endpoint=False), minor=True)\n    # -- label \n    ax01.set_ylabel(r'Real-valued field $u(x,t)$')\n\n    # (5) SET BACKGROUND GRID\n    set_grid(ax01)\n\n    # (6) SAVE FIGURE\n    save_figure(fig_format, fig_name)\n\n\ndef main():\n    x, t, uxt = fetch_data('KdV_raw_data.npz')\n    generate_figure(x, t, uxt, fig_format='png', fig_name='fig01')\n\n\nif __name__ == '__main__':\n    main()\n", "meta": {"hexsha": "543da055cdbe3351a251b18d6685f2b2c3945ea1", "size": 11655, "ext": "py", "lang": "Python", "max_stars_repo_path": "pp_figure_01.py", "max_stars_repo_name": "omelchert/IQOSeminarWeek2020", "max_stars_repo_head_hexsha": "8ecdd9cbbc56fabbfa62b13bff0b4c1634c5a5dd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pp_figure_01.py", "max_issues_repo_name": "omelchert/IQOSeminarWeek2020", "max_issues_repo_head_hexsha": "8ecdd9cbbc56fabbfa62b13bff0b4c1634c5a5dd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pp_figure_01.py", "max_forks_repo_name": "omelchert/IQOSeminarWeek2020", "max_forks_repo_head_hexsha": "8ecdd9cbbc56fabbfa62b13bff0b4c1634c5a5dd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.421875, "max_line_length": 114, "alphanum_fraction": 0.5886743887, "include": true, "reason": "import numpy", "num_tokens": 3257, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3775406828054583, "lm_q2_score": 0.18713268669577832, "lm_q1q2_score": 0.07065020231034405}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# **This notebook is for a Portuguese speaking audiance as part of a training session. Soon I will post it in English. **\n# \n# >\"Então você não se lembra de um mundo sem robôs.  Houve um tempo quando a humanidade enfrentou o universo sozinha e sem amigo. Agora ela tem criaturas para ajudá-la; criaturas mais fortes que si mesma, mais confiáveis,  mais úteis e absolutamente devotas. A humanidade não mais está sozinha. Você já pensou nisso desta forma?\" <br>\n# I, Robot - Issac Asimov, 1950\n# \n# \n# # Uma breve história dos algoritmos que aprendem\n# \n# <br><br>\n# **Bem-vindos ao Laboratório Introdutório de Machine Learning!**\n# <br><br>\n# \n# Esse é um dos livros que vamos  usar como referência [Python Machine Learning - Second Edition,\n# Raschka & Mirjalili, September-2017](https://www.packtpub.com/big-data-and-business-intelligence/python-machine-learning-second-edition)\n# \n# \n# O primeiro passo para iniciar nossos estudos  é compreender que **Machine Learning (ML)** é um sub-campo de pesquisa da **Inteleligência Artificial (IA)** e,  portanto, não é necessariamente seu sinônimo como erroneamente sugerem alguns desavisados por ai.  ** Deep Learning (DL)** é um dos tópicos de **Redes Neurais (NN's)** que por sua vez são uma das sub-áreas de **ML**.  Não cometa o erro de confundir indistintamente Deep Learning com Machine Learning.\n# ![](https://blogs.nvidia.com/wp-content/uploads/2016/07/Deep_Learning_Icons_R5_PNG.jpg.png)\n# \n# \n# \n# # Peceptron\n# Algoritmos de aprendizagem não são um tema novo.  A definição de neurônio artificial, o **perceptron**, foi estabelecida no final da década de 50 (The Perceptron: A Perceiving and Recognizing Automaton, F. Rosenblatt, Cornell Aeronautical Laboratory, 1957) e pode ser resumida na função abaixo:\n# \n# ![](https://www.dropbox.com/s/s0uvoloszvkg83x/00-Perceptron.jpg?dl=1)\n# \n# De forma simplificada, a saída de um neurônio artificial é igual a soma do produto das entradas ***x*** pelos pesos ***w*** aplicados a cada entrada.   As entradas ***x*** de um neurônio artificial equivalem aos dentritos de um neurônio biológico e a soma **$\\sum_{j=0}^m x_{j}w_{j}$** é o estímulo resultante no axônio, definido por um limiar interno do neurônio (**threshold**) que vai determinar a sua \"sensibilidade\" ou quando será ativado ou não. Em ML preferencialmente utilizaremos a notação matricial  **$w^Tx$** onde o produto é dado pela transposta de *w* por *x*. A utilização de matrizes permite maior eficiência computacional e simplificação dos códigos de ML. \n# \n# <br><BR>\n# Aqui temos a representação gráfica do perceptron:\n# \n# ![](https://www.dropbox.com/s/yxvrkm7kk1r991e/01-Perceptron.jpg?dl=1)\n\n# ![](https://www.sololearn.com/avatars/b2b6905b-4e53-412a-bcb8-22bfef2bcec5.jpg)\n# \n# # Quando as máquinas aprendem...\n# \n# A aprendizagem se traduz em encontrar pesos que aplicados aos valores de entrada resultem em um determinado valor de saída esperado.  Ainda analisando o gráfico do perceptron acima, vale notar que por questões de convenção e cálculo a entrada **$x_{0} $** é fixada com o valor ***1*** e seu o peso **$w_{0} $**  é chamado de **bias**.   Em uma rede neural de apenas uma entrada teríamos a seguinte equação equivalente z =  $w_{0}$ + $w_{1}x_{1}$.  Se voltarmos às aulas de matemática fundamental veremos que essa é exatamente uma **equação reduzida da reta **, onde $w_{0}$ define a \"altura\" da reta e  $w_{1}$ define sua inclinação no gráfico.   \n# \n# ![](https://www.dropbox.com/s/cdai4n28jp5m5wp/simple_regression.png?dl=1)\n# \n# \n# O que os algoritmos de ML fazem é buscar de forma automática a equação que melhor representa o conjunto verdade (**y**) para um conjunto de observações ou amostras de entradas.  Uma forma de encontrar a melhor equação é através do cálculo sucessivo da diferença entre os valores gerados pela equação \"aprendida\" (**ŷ**) e os valores reais observados (**y**). Essa diferença chamamos de **Erro** ou **Perda**. As funções de perda  ou **loss functions** são um importante elemento na construção de algoritmos inteligentes. Em outras palavras, podemos afirmar que a aprendizagem de máquina é essencialmente uma tarefa de otimização de funções.  Atualmente os principais frameworks de ML implementam diversos algoritmos de otimização, sendo o Gradiente Descendente Estocástico ([SGD](http://ruder.io/optimizing-gradient-descent)) um dos mais populares.\n# \n# O processo de ajustar pesos através de algoritmos de otimização de função é denominado **fit (treino)**, e cada rodada de ajustes é chamada de **Epoch (Época)**. O ajuste geralmente é feito usando um determinado número de amostras por vez que chamamos de **Batch (Lote)** .\n# \n# No gráfico acima temos um problema onde os valores de solução podem ser linearmente correlacionadas com as amostras de entrada. Neste caso um algoritmo de ** Regressão ** poderia ser aplicado, mas existem varios tipos de algoritmos de ML e cada um vai funcionar melhor em determinados cenários.  Daí o teorema  **No Free Lunch**  em Machine Learning de David H. Wolpert, que nos recorda de que nenhum algoritmo de ML é universalmente melhor que todos os outros em todos cenários (The Lack of A Priori Distinctions Between Learning Algorithms, Wolpert and David H, 1996).\n# \n# \n# \n# # Rolling in the Deep\n# \n# As redes profundas conhecidas como Deep Learning(DL) ganharam maior destaque a partir de 2012 com a vitória de um time universitário canadense em uma competição de classificação de Imagens, a [ImageNet](http://www.image-net.org/).\n# \n# Mas a vitória deste time canadense está intimamente relacionada com avanços da década de 80, sendo um de seus expoentes o cientista de computação e psicologia cognitiva **Geoffrey Hinton** da Universidade de Toronto. Hinton é conhecido por temas como **Propagação Reversa (Backpropagation)**, **Máquina de Boltzman (Boltzmann Machine** e **Deep Learning**. \n# \n# Embora o termo Deep Learning já havia sido aplicado a redes neurais artificiais por Igor Aizenberg em 2000,  foi uma plublicação de Geoffrey Hinton e Ruslan Salakhutdinov em 2006 que chamou mais atenção ao mostrar como redes neurais poderiam ser pré-treinadas uma camada por vez, e então fazer ajustes finos por meio de Backpropagation.  Esse avanço contribuiu fortemente para a viabilidade das redes DL como hoje conhecemos.\n# \n# Em 2012, Hinton e seus dois alunos Alex Krizhevsky e Ilya Sutskever entraram na competição ImageNet e ao fazerem uso de redes densas convolucionais (CNN's) e técnicas avançadas para reduzir overfitting (ajuste excessivo aos dados de treino que resulta em baixa generalização) conseguiram atingir um incrível patamar de erro de 16% contra os 25% alcançados até então com algoritmos classificadores existentes. Hinton e seus alunos criaram uma empresa que seria adquirida posteriormente pelo Google.\n# \n# Abaixo o gráfico da arquitetura de sua rede **[AlexNet](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf)** . Esta rede foi treinada por cerca de 5 a 6 dias usando um dataset de milhões de imagens classificadas milhares de classes. A equipe da AlexNet além da arquitetura inovadora utilizou duas placas de video GTX 580 (GPU) para poder suportar a alta demanda de processamento desse tipo de rede. O poder de manipulação de matrizes de uma GPU é muito bemvindo com algoritmos de ML, já que no final das contas toda informação e aprendizagem resultam em matrizes de dados e pesos.\n# \n# \n# ![](https://image.slidesharecdn.com/dlcvd2l4imagenet-160802094728/95/deep-learning-for-computer-vision-imagenet-challenge-upc-2016-7-638.jpg?cb=1470131387)\n# \n# Nos anos seguintes empresas como Nvidia, Google, Microsoft, Baidu, Amazon, IBM, Ubber, Facebook e Tesla  entrariam de forma ainda mais agressiva na corrida tecnológica por plataformas de inteligência artificial mudando o nível do jogo para uma aposta de trilhões de dólares,  e criando com o apoio das diversas comunidades de código aberto os frameworks poderosos que estão hoje ao alcance de alguns cliques. Abaixo algum dos principais frameworks da atualidade:\n# \n# ![](https://www.dropbox.com/s/lv9ooa3ur8pxc33/deep-learning-developer-frameworks-407.png?dl=1)\n\n# # O que é Machine Learning?\n# <br>\n# A seguir vamos começar a entender um pouco mais sobre como funciona os principais tipos de algoritmos de ML,  quais são as estratégias de treino e etapas para construção destes algorítimos.\n# \n# Então, uma pergunta importante a fazer é: o que é um algorítimo de aprendizagem de máquina? Uma boa definição, emprestada de [*Deep Learning*](http://www.deeplearningbook.org) (Goodfellow-et-al-2016),  seria ***\"um algorítmo de aprendizagem de máquina é um algorítmo capaz de aprender com os dados\"* **.\n# \n# Ok, mas o que significa aprender? Tom Mitchell em seu livro* Machine Learning* (McGraw-Hill, New York. 97) nos ajuda com uma definição bem sucinta: *** “Um programa de computador é dito aprender de uma experiência E em respeito a alguma classe de tarefa T e medida de performance P, se sua performance em tarefas T, como medido por P, melhora com a experiência E\".*** \n# \n# Todavia não podemos esquecer que Machine Learning é um campo em construção e muitos dos conceitos que hoje consideramos  verdade serão descartados nos próximos anos. O próprio [Geoffrey Hinton em entrevista com Andrew NG](https://www.youtube.com/watch?v=-eyhCTvrEtE) (outro nome bastante conhecido da galera de ML) diz *\"Meu conselho é que leia alguma literatura (*de ML*) mas não leia demais... alguns dizem que você deveria passar vários anos lendo a literatura e só então começar a trabalhar em suas próprias idéias e isso pode ser verdade para alguns pesquisadores, mas para pesquisadores criativos eu penso que o que você quer é estudar uma parte da literatura e, então, notar o que todos estão fazendo errado... aquilo que você sente que não está correto, e ao contrário imaginar um jeito de fazer certo... e quando os outros disserem que não serve, apenas continue... tenho um bom princípio para ajudar as pessoas a continuarem que é: ou suas intuições são boas ou não, se são boas você deveria seguir-las e ao final terá sucesso, se não são boas não importa o que você faça... você deveria confiar nas suas intuições não há razão para não fazê-lo...\"* (tradução livre)\n# \n# \n# Portanto, a seguir veremos três grandes grupos de algoritimos de ML, mas utilize essa divisão apenas como ferramenta de compreensão já que alguns algoritmos atuais extravasam essas classificações.\n# \n# \n# # Os três tipos de Machine Learning\n# \n# Os algoritmos de Machine Learning podem ser agrupados em três tipos principais:\n# \n# \n# ![](https://www.dropbox.com/s/btluyzv2e08djan/02-MLTipos.jpg?dl=1)\n# \n# ## Supervised Learning\n# O principal objetivo na **aprendizagem supervisionada** é \"aprender\" um modelo com base nos dados de treino rotulados que seja capaz fazer predições a respeito de dados novos ou de dados futuros. \n# \n# Quando os valores esperados são discretos, como por exemplo um algoritmo capaz de reconhecer se uma imagem é de um gato ou cachorro, dizemos que se trata de uma **Tarefa de Classificação** ou seja buscamos um modelo classificador.  Classificação é uma subcategoria da aprendizagem supervisionada na qual o foco é prever rótulos categóricos de novas instâncias baseado nas observações do passado.\n# \n# A predição de valores contínuos, como por exemplo o preço de venda de um imóvel, é tratada por outra subcategoria de aprendizagem supervisionada a **Regressão**.  \n# \n# \n# ## Reinforcement Learning\n# Outro tipo de aprendizagem de máquina é o aprendizado por reforço. Em **reinforcement learning** o objetivo é desenvolver um **agente** que melhora sua performance baseado em sucessivas interações com o ambiente.  Diferentemente das funções de perda (loss functions) das técnicas supervisioanadas, aqui o feedback é dado por um sistema de recompensas que pune ou premia certos resultados (**reward function**) com base em certos estados do ambiente.\n# \n# Um exemplo popular desta arquitetura de aprendizagem é uma Engine de Xadrez. Nela o agente decide uma série de movimentos de acordo com o estado do tabuleiro, a recompensa pode ser definida com base em diversos resultados como sobrepor uma peça inimiga ou tomar sua rainha, ou mesmo a vitória ou derrota final.\n# \n# \n# \n# \n# ## Unsupervised Learning\n# Na aprendizagem não supervisionada lidamos com dados não rótulados ou com informação cuja estrutura não é exatamente conhecida.   \n# \n# Ao usarmos  técnicas de aprendizagem não supervisionada somos capazes de explorar a estrutura de nossas amostras e extrair informação significativa de como essas amostras se relacionam.  Uma das aplicações práticas deste tipo de aprendizagem é a segmentação (**clustering**) de clientes de acordo com suas preferências ou quaisquer outras características que tenhamos à disposição. \n# \n# Outro campo de aplicação da aprendizagem não supervisionada é redução de dimensionalidade de dados. A redução de dimensionalidade permite eliminar ruídos e comprimir informação resultando em economia de processamento e armazenamento de dados. \n\n# # Botando a mão na massa!\n# \n# Agora que vimos em linhas gerais o que são algorítmos de ML, vamos começar com o primeiro passo no desenvolvimento de um sistema de ML:   A preparação e exploração de dados ou **exploratory data analysis (EDA)** termo também emprestado do campo de estatística.  \n# \n# Nos exemplos vou usar um famoso dataset chamado Iris que possui 150 amostras de 3 tipos de flores e os tamanhos de suas pétalas.  Em ML essas características ou dados de entrada denominamos **features**.\n# \n# *Você deve executar cada célula de código . Use Ctrl + Enter para executar e Shift + Enter para criar uma nova célula*\n# \n# ## 1 - Bibliotecas \n\n# In[ ]:\n\n\n#Usamos import para importar as bibliotecas e pacotes que vamos utilizar\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\nimport matplotlib.pyplot as plt # library for draring charts\n\n# a magic cell (%) abaixo permite exibir gráficos de forma interna adequadamente\nget_ipython().run_line_magic('matplotlib', 'inline')\n\n# Exibe a versão das biblioteca. Em alguns casos é importante em que versão está trabalhando\nprint(\"Numpy Version {}\".format(np.__version__))\nprint(\"Pandas Version {}\".format(pd.__version__))\n\n\n# ## 2 - Caminho do Dataset\n\n# In[ ]:\n\n\n'''\nO dataset que vamos usar foi adicionado automaticamente. Podemos adicionar qualquer dataset \npúblico do Kaggle com o botão \"Add a Data Source\" ou o seu próprio com \"Upload a Dataset\"\n\nOs dataset adicionados serão postos no caminho \"../input\".\nAbaixo executamos o comando linux ls através do python para listar os arquivos desta pasta:\n'''\nfrom subprocess import check_output\nprint('Arquivos Iris:')\nprint(check_output([\"ls\", \"../input/iris\"]).decode(\"utf8\"))\n\n\n# ## 3 - Carregando o Dataset\n\n# In[ ]:\n\n\n# Existem várias formas de se carregar um dataset para uso em ML as duas mais comuns:\n# usar iblioteca numpy ou carregar um data frame do pandas como abaixo\ndf_iris = pd.read_csv('../input/iris/Iris.csv')\n\n\n# In[ ]:\n\n\n# Exibe as primeiras 5 linhas do dataframe\ndf_iris.head(5)\n\n\n# ## 4 - Explorando os dados com gráficos do matplotlib\n# \n# No dataset Iris temos na coluna Species os tipos das flores que vamos analisar. Para isso precisamos transformar as classes de flores em números, para podermos seguir com as análise\n\n# **Exibindo a distribuição das classes**\n\n# In[ ]:\n\n\n# Verificamos os valores únicos para as espécies\nprint(df_iris['Species'].unique())\n\n# Adicionamos uma nova coluna no data frame e mapeamos com um valor númerico por classe\n# essa coluna é nosso target (a predição que nossa rede vai gerar)\ndf_iris['y'] = df_iris['Species'].map({'Iris-setosa': 1, 'Iris-versicolor': 2, 'Iris-virginica' : 3})\n\n# Configuramos o gráfico\nplt.xlabel('Sepal Length Cm')\nplt.ylabel('Petal Length Cm')\n#plt.scatter(x,y, c=color)\nplt.scatter(df_iris['SepalLengthCm'],df_iris['PetalLengthCm'], c=df_iris['y'])\nplt.show() # como usamos a magic cell no inicio, esse comando não é obrigatório.\n\n\n# Observando o gráfico acima podemos verificar que com apenas duas features do dataset é possível separar as classes (com uma apenas amostra como de exceção).  Esse tipo de feature é muito útil para construirmos nossos modelos de aprendizagem.\n\n# **Usando funções plot e hist do matplotlib para compreender melhor os dados:**\n\n# In[ ]:\n\n\n# Nesse grafico podemos ver que nosso dataset é bastante balanceado\nplt.title('Histograma das Classes - Cada Classe tem 50 ocorrências')\nplt.hist(df_iris['y'])\nplt.show() # Estou mantendo o comando apenas por questão de estética na saída.\n \nplt.title('Histograma da Propriedade Sepal Length\\n Maior número de amostras com valor entre 5 e 7 cm')\nplt.hist(df_iris['SepalLengthCm'], bins=6)\nplt.show()\n\n\n# In[ ]:\n\n\n#Como as amostras estão ordenadas é possível \"ver\" no gráfico onde começa e termina\n#cada grupo de 50.\nplt.figure(figsize=(15,10))\nplt.title('Exibindo as medidas por amostras')\nplt.plot ( df_iris['SepalLengthCm'], c='blue', ) \nplt.plot ( df_iris['SepalWidthCm'], c= 'red')\nplt.plot ( df_iris['PetalLengthCm'], c= 'green')\nplt.plot ( df_iris['PetalWidthCm'], c= 'yellow')\nplt.show()\n\n\n# ##  5 - Selecionando um algoritmo de ML\n# Embora seja um Dataset bem pequeno, ele é bastande balanceadol.  Vimos que as duas features  SepalLengthCm e PetalLengthCm sozinhas praticamente conseguem definir a separação das três classes mas queremos um classificador que faça o maior acerto possíve por isto vamos usar as 4 features que dispomos (O campo **Id ** será descartado para análises).  A biblioteca sckit-learn é muito útil para preparação de dados e para algoritmos que não envolvam redes neurais.\n# \n# Com dados estruturados os modelos baseados em Regressão, Decisiona Tree e Random Forests são mais indicados. Mas qui vou somente por questão de didática vamos usar uma rede neural de 3 neurônios de com 1 saída (uma para cada tipo de flor) com 4 entradas (uma para cada feature de entrada), em algorítmos de classificação o número de saídas deve ser igual ao número de classes - se não for uma classificação binária(0 ou 1, true ou false, etc).\n# \n# Não se preocupe caso não compreenda completamente alguma parte do código, vamos explorar todos detalhes nos próximos Labs, o objetivo aqui é você ver etapas gerais de uma solução completa usando Keras e TensorFlow. \n\n# In[ ]:\n\n\n#veja que ao importar o keras que é um wrapper, o TensorFlow será exibido como backend\nfrom sklearn.model_selection import train_test_split\nfrom keras.models import Sequential\nfrom keras.layers.core import Dense, Activation\nfrom keras.optimizers import SGD\nfrom keras.utils import np_utils\n\n\n# ## 6 - Feature Engineering \n# \n# Nesta fase temos a seleção das features que vão compor nosso Modelo - e seu ajuste para compatibilidade com o formato de entrada do tipo de algorítm ML selecionado.  Nossa coluna **'y'**, por exemplo contém valores de 1 a 3, esses valores serão transformados para 0 a 2 e convertidos em três colunas no formato** One-Hot**( esse tipo de codificação será explicada nos próximos labs). Além disso em muitos casos vamos ter que normalizar os valores de entrada antes entregar para uma rede neural ou algum outro tipo de algoritmo de ML.\n\n# In[ ]:\n\n\n#Número de classes possíveis\nn_classes = len(df_iris['Species'].unique()) # 3 classes\n\n#Fazemos slice do Dataframe e as convertemos em matrizes do NumPy\nx_full = np.array(df_iris.iloc[:, 1:5].values) # selecionamos as colunas de features e todas linhas\ny_full = np.array(df_iris.iloc[:, 6].values) # selecionamos todas linhas mas apenas a coluna 'y' \n\n# Para algorítimos de classificação com mais de duas classes temos que usar one-hot\n# aqui uso uma simples subtração para alterar os valores de todas a linhas y\ny_full = np_utils.to_categorical(y_full - 1, n_classes) \n\nprint(\"Vericamos se as matrizes de entrada possuem o formato correto\")\nprint(\"x_full.shape ={}    y_full.shape ={}\".format(x_full.shape, y_full.shape))\n\n\n# ## 7 - Split do dataset em treino e validação\n\n# In[ ]:\n\n\nseed = 42 # aqui ficamos o seed randômico, para garantir a reprodução de resultados\n\n# A separação do dataset é uma técnica muito importante para maior eficiência\n# da validação da eficácia de um modelo e veremos em maior detalhe nos próximos labs. \nX_train, X_val, y_train, y_val = train_test_split(x_full, y_full,\n                                                test_size=0.2, random_state=seed)\n\n# A classe train_test_split faz o embaralhamento dos dados antes\nprint(\"Novamente validamos os formatos do split:\")\nprint(X_train.shape, y_train.shape); print(X_val.shape, y_val.shape)\n\n\n# ## 8 - Definindo a arquitetura de nossa Rede Neural\n\n# In[ ]:\n\n\n# Fixamos o seed para biblioteca randômica do NumPy\nnp.random.seed(seed) \n\n#Cada implementação de um algorítimo de ML chamamos de modelo\nmodel = Sequential()  # modelo sequencial\nmodel.add(Dense(n_classes, input_shape=(4,))) # cria uma camada com 3 neurônios\nmodel.add(Activation('softmax')) # usamos ativação de threshold conhecida como softmax\nmodel.summary()\n\n\n# Se olharmos acima notamos a existência de 15 parâmetros treináveis. Cada um dos três neurônios possuem 4 entradas, uma para cada feature, portanto teremos 4 x 3  = 12, ou seja 12 pesos que devem ser treinados. E de onde vem os 15?  \n# \n# Lembra que para cada neurônio vamos ter uma entrada $x_{0}$ igual a 1 e um peso peso $w_{0}$ que será seu **bias**?   Então como temos 3 neurônios teremos 3 biases a serem treinados. Dai 12 pesos + 3 biases, resultando em 15 parâmetros treináveis.\n\n# ## 9 - Compilando e Treinando nosso Modelo (Finalmente!!)\n\n# In[ ]:\n\n\nimport timeit\n\nn_epoch = 500 # Número de Épocas\nbatch_size = 10 #tamanho do Batch (quantidade de amostras por lote de treino)\n\n#Aqui vamos usar o Gradiente Descendente Estocástico, que é um tipo de otimizador\nsgd = SGD(lr= 0.1) # lr é o Learning Rate conceito que vamos ver nos próximos labs.\n\n#Todo modelo precisa ser compilado, veja que no parâmetro loss informamos a função de erro\nmodel.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy']) \n\n#Inicia contagem do tempo\nstart = timeit.default_timer()\n\n# Aqui fazemos o fit do modelo e salvamos o resultado de cada epoca em history\nhistory = model.fit(X_train, y_train, batch_size=batch_size, epochs=n_epoch,verbose=0) \n\n#Inicia contagem do tempo\nelapsed = timeit.default_timer() - start\n\nprint(\"Rede Treinada em {} épocas durante {:.4f} segundos\".format(n_epoch, elapsed))\n\n\n# ## 10 - Avaliando o quão inteligente é nosso algorítimo\n\n# In[ ]:\n\n\n_, train_accuracy = model.evaluate(X_train, y_train, verbose=0)\n_, val_accuracy = model.evaluate(X_val, y_val, verbose=0)\n\nprint('Acurácia no Treino: {:.2f}%'.format(train_accuracy * 100))\nprint('Acurácia na Validação: {:.2f}%'.format(val_accuracy * 100))\n\n\n# A acurácia é uma métrica que indica em percentual quantas amostras do todo foram classificadas corretamente.  \n# ***Acurária = Número de Acertos / Número de Testes***\n# \n# Em nosso dataset de treino conseguimos 117 acertos em 120 amostras (ou testes); e 30 acertos em 30 amostras no conjunto de teste. Com isso temos uma acurácia de 97,5% no treino e de 100% no dataset de teste.\n# \n# Uau!!! Um excelente resultado com cerca de 5 segundos de treino e uma rede de somente 3 neurônios e um mínimo ajuste de **hiperparâmetro**, o **Learning Rate** (LR=0.1). \n# \n# Hiperparâmetros serão tema para um próximo lab. Fiquem a vontade para fazer Fork desse Kernel e testar valores diferentes para número de épocas, batch size e tipo de otimizador.  \n\n# ** Matrix de Confusão** \n# \n# Esta é uma outra forma de visualizar a acurácia de uma rede, geralmente aplicamos somente no dataset de validação.\n# Aqui apliquei nos dois para poder exibir onde nosso algoritmo errou.\n\n# In[ ]:\n\n\ny_hat_train = model.predict_classes(X_train)\npd.crosstab(y_hat_train, np.argmax(y_train, axis=1)) \n\n\n# In[ ]:\n\n\ny_hat_val = model.predict_classes(X_val)\npd.crosstab(y_hat_val, np.argmax(y_val, axis=1))\n\n\n# Se olharmos as duas matrizes de confusão veremos que nosso modelo errou apenas 3 amostras das 150. Um ótimo feito para uma rede de penas uma camada densa de 3 neurônios.\n\n# ## 11 - Verificando a curva de aprendizagem de sua rede\n# É possível verificar que a partir da época 300 não há grande melhoria (diminuição do erro)\n\n# In[ ]:\n\n\n# a impressão dos valores de perda a cada época de treinamento\n# permite ter valiosos insights sobre como seu modelo se comporta durante o treinamento\nplt.figure(figsize=(10,8))\nplt.plot(history.history['loss'], label='Erro')\nplt.plot(history.history['acc'], label='Acurácia')\nplt.legend(loc='upper center')\nplt.show()\n\n\n# ## Tarefas do Lab\n# \n# Crie um fork deste notebook em sua conta (assim você trabalha em sua própria cópia), e nos quadros abaixo escreva código para carregar o dataset  **House Sales in King County** (kc_house_data.csv) que já está copiado na pasta **../input/housesalesprediction** .  Se necessário crie novas células com Alt + Enter.\n# \n\n# ### 1 - Carregar o Dataset House Sales de King County\n\n# In[ ]:\n\n\nprint('Arquivo House Sales:')\nprint(check_output([\"ls\", \"../input/housesalesprediction\"]).decode(\"utf8\"))\n\n\n# In[ ]:\n\n\n#Usando pandas crie um dataframe para armazenar o dataset House Sales\n#df_house = pd.read_csv...\n\n\n# ### 2 - Exibir as 20 primeiras linhas e as últimas 5 do data frame df_house\n\n# In[ ]:\n\n\n#Crie seu código abaixo\n\n\n# ### 3 - Adicione uma nova coluna no dataframe com o nome 'yearsale' (o campo date possui a data da venda)\n\n# In[ ]:\n\n\n#\n\n\n# ### 4 - Criar um gráfico que relacione o ano de cosntrução (yr_built) com o valor da venda (price)\n# Aqui é possível utilizar a função plot ou scatter, veja qual funciona melhor.\n\n# In[ ]:\n\n\n#\n\n\n# ### 5 - Mostrar o histograma de distribuição das vendas de acordo com o local (zipcode), preço de venda (price) e tamanho das casas (sqft_living)\n\n# In[ ]:\n\n\n\n\n\n# ### 6 - Avaliando de forma geral o conteúdo deste dataset qual ou quais colunas você acredita que tenha maior impacto sobre o valor da venda do imóvel?  Correlacione essas colunas com a coluna price. Plote gráficos que justifiquem sua resposta.\n\n# In[ ]:\n\n\n\n\n\n# ### 7 - Em ML recorremos ao conceito estatístico *Outlier*. Dada uma série de dados uma amostra que possua um valor muito destoante do restante é considerado um *outlier*.   Em algumas análises reconhecer outliers pode ser de grande ajuda para entender a natureza dos dados a serem explorados.  Como você faria para identificar a existência de outliers ao verificarmos o valor das vendas deste dataset?  Dica tente usar gráficos scatter e hist.  \n\n# In[ ]:\n\n\n\n\n\n# ### 8 - Usando Python e NumPy calcule o valor médio do square feet (pode utilizar a coluna sqft_living para o cálculo) e crie um gráfico para exibir todas as amostras cujo valor do square feet de venda seja maior que o valor médio.\n\n# In[ ]:\n\n\n\n\n\n# \n\n# \n\n# \n\n# \n\n# \n\n# \n", "meta": {"hexsha": "783e9ed5628996951e3d5805a950b3d2fdc79b58", "size": 26889, "ext": "py", "lang": "Python", "max_stars_repo_path": "downloaded_kernels/house_sales/converted_notebooks/kernel_54.py", "max_stars_repo_name": "josepablocam/common-code-extraction", "max_stars_repo_head_hexsha": "a6978fae73eee8ece6f1db09f2f38cf92f03b3ad", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "downloaded_kernels/house_sales/converted_notebooks/kernel_54.py", "max_issues_repo_name": "josepablocam/common-code-extraction", "max_issues_repo_head_hexsha": "a6978fae73eee8ece6f1db09f2f38cf92f03b3ad", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "downloaded_kernels/house_sales/converted_notebooks/kernel_54.py", "max_forks_repo_name": "josepablocam/common-code-extraction", "max_forks_repo_head_hexsha": "a6978fae73eee8ece6f1db09f2f38cf92f03b3ad", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-12T00:48:08.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-11T12:53:05.000Z", "avg_line_length": 55.7863070539, "max_line_length": 1178, "alphanum_fraction": 0.7606456172, "include": true, "reason": "import numpy", "num_tokens": 7554, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.42250462027098473, "lm_q2_score": 0.16667539640920676, "lm_q1q2_score": 0.07042112506838775}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Applying statistical modeling and machine learning to perform time-series forecasting.\n\n# Tamara Louie  \n# PyData LA  \n# October 2018\n\n# # Time-series data due diligence\n\n# ## Read in my data\n# **Please download from http://insideairbnb.com/get-the-data.html the following CSV file (23 MB) under the \"Los Angeles\" section:**\n# \n# \treviews.csv\n#   \n# \n# You should have **reviews.csv** stored somewhere locally. \n# \n# Run the cell below, and click on the button **Choose Files**, to select your **reviews.csv** to upload.  \n# \n# *Note: It will take some time to upload this data, so please start your upload and this upload will run for a couple of minutes.*\n\n# In[6]:\n\n\nimport pandas as pd\n\nuploaded = pd.read_csv(\"reviews.csv\")\n\nfor fn in uploaded.keys():\n  print('User uploaded file \"{name}\" with length {length} bytes'.format(\n      name=fn, length=len(uploaded[fn])))\n\n\n# ## Import some relevant packages\n# Ideally, one should set up their own virtual environment and determine the versions of each library that they are using.  Here, we will assume that the colaboratory environment has some shared environment with access to common Python libraries and the ability to install other libraries necessary.\n\n# In[7]:\n\n\n# import packages\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nget_ipython().run_line_magic('matplotlib', 'inline')\nfrom IPython.display import display, HTML, display_html\nimport seaborn as sns\nimport datetime\n\n\n# set formatting\npd.set_option('display.max_columns', 100)\npd.set_option('display.max_rows', 100)\n\n# read in CSV file data\ndf = pd.read_csv('reviews.csv')\n\n\n# ## Look at my data\n# - How many rows are in the dataset?\n# - How many columns are in this dataset?\n# - What data types are the columns?\n# - Is the data complete? Are there nulls? Do we have to infer values?\n# - What is the definition of these columns?\n# - What are some other caveats to the data?\n# \n\n# In[8]:\n\n\n# look at data\ndisplay(df.head())\n\n# look a shape of data\ndisplay(df.shape)\n\n# look at data types. Ideally look at all rows. Only look at first five here for minimal output.\ndisplay(df.iloc[:5,:5].dtypes)\n\n# see if any columns have nulls. Ideally look at all rows. Only look at first five here for minimal output.\ndisplay(df.iloc[:5,:5].isnull().any())\n\n# display descriptive statistics\ndisplay(df.describe(percentiles=[0.25,0.5,0.75,0.85,0.95,0.99]))\n\n\n# ## What are some questions I can answer with this data?\n# \n# Understand the limitations of your data and what potential questions can be answered by data is important.  These questions can reduce, expand, or modify the scope of your project.\n# \n# If you defined a scope or goal for your project before digging into the data, this might be a good time to revisit it.\n# \n# **Data.** We have daily count of reviews for given listing ids for given dates.\n# \n# **Questions I could try to answer. **\n# \n# *   Forecast future number of reviews for the Los Angeles area.\n# * Forecast the future number of reviews for specific listings in the Los Angeles area.\n\n# ## What techniques may help answer these questions?\n# ### Statistical models\n# *   **Ignore the time-series aspect completely and model using traditional statistical modeling toolbox.** \n#   *   *Examples.* Regression-based models.  \n# *   **Univariate statistical time-series modeling.**\n#   *   *Examples.* Averaging and smoothing models, ARIMA models.\n# *   **Slight modifications to univariate statistical time-series modeling.**\n#   *    *Examples.* External regressors, multi-variate models.\n# *   **Additive or component models.**\n#   *  *Examples.* Facebook Prophet package.\n# *   **Structural time series modeling.**\n#   *    *Examples.* Bayesian structural time series modeling, hierarchical time series modeling.\n# \n# ### Machine learning models\n# \n# *   **Ignore the time-series aspect completely and model using traditional machine learning modeling toolbox.** \n#   *   *Examples.* Support Vector Machines (SVMs), Random Forest Regression, Gradient-Boosted Decision Trees (GBDTs).\n# *   **Hidden markov models (HMMs).**\n# *   **Other sequence-based models.**\n# *   **Gaussian processes (GPs).**\n# *   **Recurrent neural networks (RNNs).**\n#   \n# ### Additional data considerations before choosing a model\n# *   Whether or not to incorporate external data\n# *   Whether or not to keep as univariate or multivariate (i.e., which features and number of features)\n# *   Outlier detection and removal\n# *   Missing value imputation\n\n# # Let's analyze some time-series data!\n# \n# - [Link 1](https://www.analyticsvidhya.com/blog/2016/02/time-series-forecasting-codes-python/)\n# - [Link 2](https://content.nexosis.com/blog/methods-of-demand-forecasting-bsts-prophet)\n\n# ## Process my data\n\n# In[9]:\n\n\n# Rename columns\ndf = df.rename(columns = {'date': 'ds', 'listing_id': 'ts'})\n\n# Group data by number of listings per date\ndf_example = df.groupby(by = 'ds').agg({'ts': 'count'})\n\n# Change index to datetime\ndf_example.index = pd.to_datetime(df_example.index)\n\n# Set frequency of time series\ndf_example = df_example.asfreq(freq='1D')\n\n# Sort the values\ndf_example = df_example.sort_index(ascending = True)\n\n# Fill values with 0\ndf_example = df_example.fillna(value = 0)\n\n# Show the end of the data\ndisplay(df_example.tail())\n\n\n# ## Plot my data\n# - There does appear to be an overall increasing trend. \n# - There appears to be some differences in the variance over time. \n# - There may be some seasonality (i.e., cycles) in the data.\n# - Not sure about outliers.\n\n# In[10]:\n\n\n# Plot time series data\nf, ax = plt.subplots(1,1)\nax.plot(df_example['ts'])\n\n# Add title\nax.set_title('Time-series graph for 1 time-series example')\n\n# Rotate x-labels\nax.tick_params(axis = 'x', rotation = 45)\n\n# Show graph\nplt.show()\nplt.close()\n\n\n# ## Look at stationarity\n# Most time-series models assume that the underlying time-series data is **stationary**.  This assumption gives us some nice statistical properties that allows us to use various models for forecasting.\n# \n# **Stationarity** is a statistical assumption that a time-series has:\n# *   **Constant mean**\n# *   **Constant variance**\n# *   **Autocovariance does not depend on time**\n# \n# More simply put, if we are using past data to predict future data, we should assume that the data will follow the same general trends and patterns as in the past.  This general statement holds for most training data and modeling tasks.\n# \n# **There are some good diagrams and explanations on stationarity [here](https://www.analyticsvidhya.com/blog/2015/12/complete-tutorial-time-series-modeling/) and [here](https://people.duke.edu/~rnau/411diff.htm).**\n# \n# Sometimes we need to transform the data in order to make it stationary.  However, this  transformation then calls into question if this data is truly stationary and is suited to be modeled using these techniques.\n# \n# **Looking at our data:**\n# - Rolling mean and standard deviation look like they change over time.  There may be some de-trending and removing seasonality involved. Based on **Dickey-Fuller test**, because p = 0.31, we fail to reject the null hypothesis (that the time series is not stationary) at the p = 0.05 level, thus concluding that we fail to reject the null hypothesis that our **time series is not stationary**.\n\n# In[14]:\n\n\nfrom statsmodels.tsa.stattools import adfuller\ndef test_stationarity(df, ts):\n    \"\"\"\n    Test stationarity using moving average statistics and Dickey-Fuller test\n    Source: https://www.analyticsvidhya.com/blog/2016/02/time-series-forecasting-codes-python/\n    \"\"\"\n    \n    # Determing rolling statistics\n    rolmean = df[ts].rolling(window = 12, center = False).mean()\n    rolstd = df[ts].rolling(window = 12, center = False).std()\n    \n    # Plot rolling statistics:\n    orig = plt.plot(df[ts], \n                    color = 'blue', \n                    label = 'Original')\n    mean = plt.plot(rolmean, \n                    color = 'red', \n                    label = 'Rolling Mean')\n    std = plt.plot(rolstd, \n                   color = 'black', \n                   label = 'Rolling Std')\n    plt.legend(loc = 'best')\n    plt.title('Rolling Mean & Standard Deviation for %s' %(ts))\n    plt.xticks(rotation = 45)\n    plt.show(block = False)\n    plt.close()\n    \n    # Perform Dickey-Fuller test:\n    # Null Hypothesis (H_0): time series is not stationary\n    # Alternate Hypothesis (H_1): time series is stationary\n    print('Results of Dickey-Fuller Test:')\n    dftest = adfuller(df[ts], \n                      autolag='AIC')\n    dfoutput = pd.Series(dftest[0:4], \n                         index = ['Test Statistic',\n                                  'p-value',\n                                  '# Lags Used',\n                                  'Number of Observations Used'])\n    for key, value in dftest[4].items():\n        dfoutput['Critical Value (%s)'%key] = value\n    print dfoutput\n\n\n# In[12]:\n\n\ntest_stationarity(df = df_example, ts = 'ts')\n\n\n# ## Correct for stationarity\n# \n# It is common for time series data to have to correct for non-stationarity. \n# \n# 2 common reasons behind non-stationarity are:\n# \n# 1. **Trend** – mean is not constant over time.\n# 2. **Seasonality** – variance is not constant over time.\n# \n# There are ways to correct for trend and seasonality, to make the time series stationary.\n\n# **What happens if you do not correct for these things?**\n# \n# Many things can happen, including:\n# - Variance can be mis-specified\n# - Model fit can be worse.  \n# - Not leveraging valuable time-dependent nature of the data.  \n# \n# Here are some resources on the pitfalls of using traditional methods for time series analysis.  \n# [Quora link](https://www.quora.com/Why-cant-you-use-linear-regression-for-time-series-data)  \n# [Quora link](https://www.quora.com/Data-Science-Can-machine-learning-be-used-for-time-series-analysis)  \n# \n\n# ## Eliminating trend and seasonality\n# *   **Transformation**\n#   *   *Examples.* Log, square root, etc.\n#   *   We are going to look at log.\n# *   **Smoothing**\n#   *  *Examples.* Weekly average, monthly average, rolling averages.\n#   *   We are going to look at weekly average.\n# *   **Differencing**\n#   *  *Examples.* First-order differencing.\n#   *   We are going to look at first-order differencing.\n# *   **Polynomial Fitting**\n#   *  *Examples.* Fit a regression model.\n# *   **Decomposition**\n\n# ## Transformation, Smoothing, and Differencing\n# **Looking at our data:**\n# - Applying log transformation, weekly moving average smoothing, and differencing made the data more stationary over time. Based on **Dickey-Fuller test**, because p = < 0.05, we fail to reject the null hypothesis (that the time series is not stationary) at the p = 0.05 level, thus concluding that the **time series is stationary**.\n\n# In[1]:\n\n\ndef plot_transformed_data(df, ts, ts_transform):\n  \"\"\"\n  Plot transformed and original time series data\n  \"\"\"\n  # Plot time series data\n  f, ax = plt.subplots(1,1)\n  ax.plot(df[ts])\n  ax.plot(df[ts_transform], color = 'red')\n\n  # Add title\n  ax.set_title('%s and %s time-series graph' %(ts, ts_transform))\n\n  # Rotate x-labels\n  ax.tick_params(axis = 'x', rotation = 45)\n\n  # Add legend\n  ax.legend([ts, ts_transform])\n  \n  plt.show()\n  plt.close()\n  \n  return\n\n\n# In[2]:\n\n\n# Transformation - log ts\ndf_example['ts_log'] = df_example['ts'].apply(lambda x: np.log(x))\n\n# Transformation - 7-day moving averages of log ts\ndf_example['ts_log_moving_avg'] = df_example['ts_log'].rolling(window = 7,\n                                                               center = False).mean()\n\n# Transformation - 7-day moving average ts\ndf_example['ts_moving_avg'] = df_example['ts'].rolling(window = 7,\n                                                       center = False).mean()\n\n# Transformation - Difference between logged ts and first-order difference logged ts\n# df_example['ts_log_diff'] = df_example['ts_log'] - df_example['ts_log'].shift()\ndf_example['ts_log_diff'] = df_example['ts_log'].diff()\n\n# Transformation - Difference between ts and moving average ts\ndf_example['ts_moving_avg_diff'] = df_example['ts'] - df_example['ts_moving_avg']\n\n# Transformation - Difference between logged ts and logged moving average ts\ndf_example['ts_log_moving_avg_diff'] = df_example['ts_log'] - df_example['ts_log_moving_avg']\n\n# Transformation - Difference between logged ts and logged moving average ts\ndf_example_transform = df_example.dropna()\n\n# Transformation - Logged exponentially weighted moving averages (EWMA) ts\ndf_example_transform['ts_log_ewma'] = df_example_transform['ts_log'].ewm(halflife = 7,\n                                                                         ignore_na = False,\n                                                                         min_periods = 0,\n                                                                         adjust = True).mean()\n\n# Transformation - Difference between logged ts and logged EWMA ts\ndf_example_transform['ts_log_ewma_diff'] = df_example_transform['ts_log'] - df_example_transform['ts_log_ewma']\n\n# Display data\ndisplay(df_example_transform.head())\n\n# Plot data\nplot_transformed_data(df = df_example, \n                      ts = 'ts', \n                      ts_transform = 'ts_log')\n# Plot data\nplot_transformed_data(df = df_example, \n                      ts = 'ts_log', \n                      ts_transform = 'ts_log_moving_avg')\n\n# Plot data\nplot_transformed_data(df = df_example_transform, \n                      ts = 'ts', \n                      ts_transform = 'ts_moving_avg')\n\n# Plot data\nplot_transformed_data(df = df_example_transform, \n                      ts = 'ts_log', \n                      ts_transform = 'ts_log_diff')\n\n# Plot data\nplot_transformed_data(df = df_example_transform, \n                      ts = 'ts', \n                      ts_transform = 'ts_moving_avg_diff')\n\n# Plot data\nplot_transformed_data(df = df_example_transform, \n                      ts = 'ts_log', \n                      ts_transform = 'ts_log_moving_avg_diff')\n\n# Plot data\nplot_transformed_data(df = df_example_transform, \n                      ts = 'ts_log', \n                      ts_transform = 'ts_log_ewma')\n\n# Plot data\nplot_transformed_data(df = df_example_transform, \n                      ts = 'ts_log', \n                      ts_transform = 'ts_log_ewma_diff')\n\n# Perform stationarity test\ntest_stationarity(df = df_example_transform, \n                  ts = 'ts_log')\n\n# Perform stationarity test\ntest_stationarity(df = df_example_transform, \n                  ts = 'ts_moving_avg')\n\n# Perform stationarity test\ntest_stationarity(df = df_example_transform, \n                  ts = 'ts_log_moving_avg')\n\n# Perform stationarity test\ntest_stationarity(df = df_example_transform,\n                  ts = 'ts_log_diff')\n\n# Perform stationarity test\ntest_stationarity(df = df_example_transform,\n                  ts = 'ts_moving_avg_diff')\n\n# Perform stationarity test\ntest_stationarity(df = df_example_transform,\n                  ts = 'ts_log_moving_avg_diff')\n\n# Perform stationarity test\ntest_stationarity(df = df_example_transform, \n                  ts = 'ts_log_ewma')\n\n# Perform stationarity test\ntest_stationarity(df = df_example_transform,\n                  ts = 'ts_log_ewma_diff')\n\n\n# ## Decomposition: trend, seasonality, residuals\n# **Looking at our data:**\n# - De-trending and de-seasonalizing made the data (i.e., the residuals) more stationary over time. Based on **Dickey-Fuller test**, because p = < 0.05, we fail to reject the null hypothesis (that the time series is not stationary) at the p = 0.05 level, thus concluding that the **time series is stationary**.\n\n# In[23]:\n\n\ndef plot_decomposition(df, ts, trend, seasonal, residual):\n  \"\"\"\n  Plot time series data\n  \"\"\"\n  f, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2,2, figsize = (15, 5), sharex = True)\n\n  ax1.plot(df[ts], label = 'Original')\n  ax1.legend(loc = 'best')\n  ax1.tick_params(axis = 'x', rotation = 45)\n\n  ax2.plot(df[trend], label = 'Trend')\n  ax2.legend(loc = 'best')\n  ax2.tick_params(axis = 'x', rotation = 45)\n\n  ax3.plot(df[seasonal],label = 'Seasonality')\n  ax3.legend(loc = 'best')\n  ax3.tick_params(axis = 'x', rotation = 45)\n\n  ax4.plot(df[residual], label = 'Residuals')\n  ax4.legend(loc = 'best')\n  ax4.tick_params(axis = 'x', rotation = 45)\n  plt.tight_layout()\n\n  # Show graph\n  plt.suptitle('Trend, Seasonal, and Residual Decomposition of %s' %(ts), \n               x = 0.5, \n               y = 1.05, \n               fontsize = 18)\n  plt.show()\n  plt.close()\n  \n  return\n\n\n# In[24]:\n\n\nfrom statsmodels.tsa.seasonal import seasonal_decompose\ndecomposition = seasonal_decompose(df_example_transform['ts_log'], freq = 365)\n\ndf_example_transform.loc[:,'trend'] = decomposition.trend\ndf_example_transform.loc[:,'seasonal'] = decomposition.seasonal\ndf_example_transform.loc[:,'residual'] = decomposition.resid\n\nplot_decomposition(df = df_example_transform, \n                   ts = 'ts_log', \n                   trend = 'trend',\n                   seasonal = 'seasonal', \n                   residual = 'residual')\n\ntest_stationarity(df = df_example_transform.dropna(), ts = 'residual')\n\n\n# # Let us model some time-series data! Finally! ARIMA models.\n# \n# We will be doing an example here! We can use ARIMA models when we know there is dependence between values and we can leverage that information to forecast.\n# \n# **ARIMA = Auto-Regressive Integrated Moving Average**.   \n# **Assumptions.** The time-series is stationary.  \n# **Depends on:**  \n#   **1. Number of AR (Auto-Regressive) terms (p).**  \n#   **2. Number of I (Integrated or Difference) terms (d).**  \n#   **3. Number of MA (Moving Average) terms (q).**  \n\n# ## ACF and PACF Plots\n# **How do we determine p, d, and q?**\n# For p and q, we can use ACF and PACF plots (below).\n# \n# **Autocorrelation Function (ACF).** Correlation between the time series with a lagged version of itself (e.g., correlation of Y(t) with Y(t-1)).\n# \n# **Partial Autocorrelation Function (PACF).** Additional correlation explained by each successive lagged term.\n# \n# **How do we interpret ACF and PACF plots?**\n# - p – Lag value where the PACF chart crosses the upper confidence interval for the first time.\n# - q – Lag value where the ACF chart crosses the upper confidence interval for the first time.\n# \n\n# In[25]:\n\n\ndef plot_acf_pacf(df, ts):\n  \"\"\"\n  Plot auto-correlation function (ACF) and partial auto-correlation (PACF) plots\n  \"\"\"\n  f, (ax1, ax2) = plt.subplots(1,2, figsize = (10, 5)) \n\n  #Plot ACF: \n\n  ax1.plot(lag_acf)\n  ax1.axhline(y=0,linestyle='--',color='gray')\n  ax1.axhline(y=-1.96/np.sqrt(len(df[ts])),linestyle='--',color='gray')\n  ax1.axhline(y=1.96/np.sqrt(len(df[ts])),linestyle='--',color='gray')\n  ax1.set_title('Autocorrelation Function for %s' %(ts))\n\n  #Plot PACF:\n  ax2.plot(lag_pacf)\n  ax2.axhline(y=0,linestyle='--',color='gray')\n  ax2.axhline(y=-1.96/np.sqrt(len(df[ts])),linestyle='--',color='gray')\n  ax2.axhline(y=1.96/np.sqrt(len(df[ts])),linestyle='--',color='gray')\n  ax2.set_title('Partial Autocorrelation Function for %s' %(ts))\n  \n  plt.tight_layout()\n  plt.show()\n  plt.close()\n  \n  return\n\n\n# In[26]:\n\n\n#ACF and PACF plots:\nfrom statsmodels.tsa.stattools import acf, pacf\n\n# determine ACF and PACF\nlag_acf = acf(np.array(df_example_transform['ts_log_diff']), nlags = 20)\nlag_pacf = pacf(np.array(df_example_transform['ts_log_diff']), nlags = 20)\n\n# plot ACF and PACF\nplot_acf_pacf(df = df_example_transform, ts = 'ts_log_diff')\n\n\n# In[27]:\n\n\ndef run_arima_model(df, ts, p, d, q):\n  \"\"\"\n  Run ARIMA model\n  \"\"\"\n  from statsmodels.tsa.arima_model import ARIMA\n\n  # fit ARIMA model on time series\n  model = ARIMA(df[ts], order=(p, d, q))  \n  results_ = model.fit(disp=-1)  \n  \n  # get lengths correct to calculate RSS\n  len_results = len(results_.fittedvalues)\n  ts_modified = df[ts][-len_results:]\n  \n  # calculate root mean square error (RMSE) and residual sum of squares (RSS)\n  rss = sum((results_.fittedvalues - ts_modified)**2)\n  rmse = np.sqrt(rss / len(df[ts]))\n  \n  # plot fit\n  plt.plot(df[ts])\n  plt.plot(results_.fittedvalues, color = 'red')\n  plt.title('For ARIMA model (%i, %i, %i) for ts %s, RSS: %.4f, RMSE: %.4f' %(p, d, q, ts, rss, rmse))\n  \n  plt.show()\n  plt.close()\n  \n  return results_\n\n\n# In[28]:\n\n\n# Note: I do the differencing in the transformation of the data 'ts_log_diff'\n# AR model with 1st order differencing - ARIMA (1,0,0)\nmodel_AR = run_arima_model(df = df_example_transform, \n                           ts = 'ts_log_diff', \n                           p = 1, \n                           d = 0, \n                           q = 0)\n\n# MA model with 1st order differencing - ARIMA (0,0,1)\nmodel_MA = run_arima_model(df = df_example_transform, \n                           ts = 'ts_log_diff', \n                           p = 0, \n                           d = 0, \n                           q = 1)\n\n# ARMA model with 1st order differencing - ARIMA (1,0,1)\nmodel_MA = run_arima_model(df = df_example_transform, \n                           ts = 'ts_log_diff', \n                           p = 1, \n                           d = 0, \n                           q = 1)\n\n\n# # Let us model some time-series data! Finally! Facebook Prophet package.\n# \n# We will be doing an example here! Installing the necessary packages might take a couple of minutes.  In the meantime, I can talk a bit about [Facebook Prophet](https://facebook.github.io/prophet/), a tool that allows folks to forecast using additive or component models relatively easily.  It can also include things like:\n# * Day of week effects\n# * Day of year effects\n# * Holiday effects\n# * Trend trajectory\n# * Can do MCMC sampling\n\n# In[29]:\n\n\nget_ipython().system('pip install pystan')\nget_ipython().system('pip install fbprophet')\nfrom fbprophet import Prophet\nimport datetime\nfrom datetime import datetime\n\n\n# In[30]:\n\n\ndef days_between(d1, d2):\n    \"\"\"Calculate the number of days between two dates.  D1 is start date (inclusive) and d2 is end date (inclusive)\"\"\"\n    d1 = datetime.strptime(d1, \"%Y-%m-%d\")\n    d2 = datetime.strptime(d2, \"%Y-%m-%d\")\n    return abs((d2 - d1).days + 1)\n\n\n# In[31]:\n\n\n# Inputs for query\n\ndate_column = 'dt'\nmetric_column = 'ts'\ntable = df_example\nstart_training_date = '2010-07-03'\nend_training_date = '2018-09-08'\nstart_forecasting_date = '2018-09-09'\nend_forecasting_date = '2018-12-31'\nyear_to_estimate = '2018'\n\n# Inputs for forecasting\n\n# future_num_points\n# If doing different time intervals, change future_num_points\nfuture_num_points = days_between(start_forecasting_date, end_forecasting_date)\n\ncap = None # 2e6\n\n# growth: default = 'linear'\n# Can also choose 'logistic'\ngrowth = 'linear'\n\n# n_changepoints: default = 25, uniformly placed in first 80% of time series\nn_changepoints = 25 \n\n# changepoint_prior_scale: default = 0.05\n# Increasing it will make the trend more flexible\nchangepoint_prior_scale = 0.05 \n\n# changpoints: example = ['2016-01-01']\nchangepoints = None \n\n# holidays_prior_scale: default = 10\n# If you find that the holidays are overfitting, you can adjust their prior scale to smooth them\nholidays_prior_scale = 10 \n\n# interval_width: default = 0.8\ninterval_width = 0.8 \n\n# mcmc_samples: default = 0\n# By default Prophet will only return uncertainty in the trend and observation noise.\n# To get uncertainty in seasonality, you must do full Bayesian sampling. \n# Replaces typical MAP estimation with MCMC sampling, and takes MUCH LONGER - e.g., 10 minutes instead of 10 seconds.\n# If you do full sampling, then you will see the uncertainty in seasonal components when you plot:\nmcmc_samples = 0\n\n# holiday: default = None\n# thanksgiving = pd.DataFrame({\n#   'holiday': 'thanksgiving',\n#   'ds': pd.to_datetime(['2014-11-27', '2015-11-26',\n#                         '2016-11-24', '2017-11-23']),\n#   'lower_window': 0,\n#   'upper_window': 4,\n# })\n# christmas = pd.DataFrame({\n#   'holiday': 'christmas',\n#   'ds': pd.to_datetime(['2014-12-25', '2015-12-25', \n#                         '2016-12-25','2017-12-25']),\n#   'lower_window': -1,\n#   'upper_window': 0,\n# })\n# holidays = pd.concat((thanksgiving,christmas))\nholidays = None\n\ndaily_seasonality = True\n\n\n# In[32]:\n\n\n# get relevant data - note: could also try this with ts_log_diff\ndf_prophet = df_example_transform[['ts']] # can try with ts_log_diff\n\n# reset index\ndf_prophet = df_prophet.reset_index()\n\n# rename columns\ndf_prophet = df_prophet.rename(columns = {'ds': 'ds', 'ts': 'y'}) # can try with ts_log_diff\n\n# Change 'ds' type from datetime to date (necessary for FB Prophet)\ndf_prophet['ds'] = pd.to_datetime(df_prophet['ds'])\n\n# Change 'y' type to numeric (necessary for FB Prophet)\ndf_prophet['y'] = pd.to_numeric(df_prophet['y'], errors='ignore')\n\n# Remove any outliers\n# df.loc[(df_['ds'] > '2016-12-13') & (df_['ds'] < '2016-12-19'), 'y'] = None\n\n\n# In[33]:\n\n\ndef create_daily_forecast(df,\n#                           cap,\n                          holidays,\n                          growth,\n                          n_changepoints = 25,\n                          changepoint_prior_scale = 0.05,\n                          changepoints = None,\n                          holidays_prior_scale = 10,\n                          interval_width = 0.8,\n                          mcmc_samples = 1,\n                          future_num_points = 10, \n                          daily_seasonality = True):\n  \"\"\"\n  Create forecast\n  \"\"\"\n  \n  # Create copy of dataframe\n  df_ = df.copy()\n\n  # Add in growth parameter, which can change over time\n  #     df_['cap'] = max(df_['y']) if cap is None else cap\n\n  # Create model object and fit to dataframe\n  m = Prophet(growth = growth,\n              n_changepoints = n_changepoints,\n              changepoint_prior_scale = changepoint_prior_scale,\n              changepoints = changepoints,\n              holidays = holidays,\n              holidays_prior_scale = holidays_prior_scale,\n              interval_width = interval_width,\n              mcmc_samples = mcmc_samples, \n              daily_seasonality = daily_seasonality)\n\n  # Fit model with dataframe\n  m.fit(df_)\n\n  # Create dataframe for predictions\n  future = m.make_future_dataframe(periods = future_num_points)\n  #     future['cap'] = max(df_['y']) if cap is None else cap\n\n  # Create predictions\n  fcst = m.predict(future)\n\n  # Plot\n  m.plot(fcst);\n  m.plot_components(fcst)\n\n  return fcst\n\n\n# In[ ]:\n\n\nfcst = create_daily_forecast(df_prophet,\n#                              cap,\n                             holidays,\n                             growth,\n                             n_changepoints,\n                             changepoint_prior_scale,\n                             changepoints, \n                             holidays_prior_scale,\n                             interval_width,\n                             mcmc_samples,\n                             future_num_points, \n                             daily_seasonality)\n\n\n# In[ ]:\n\n\ndef calculate_mape(y_true, y_pred):\n    \"\"\" Calculate mean absolute percentage error (MAPE)\"\"\"\n    return np.mean(np.abs((y_true - y_pred) / y_true)) * 100\n\ndef calculate_mpe(y_true, y_pred):\n    \"\"\" Calculate mean percentage error (MPE)\"\"\"\n    return np.mean((y_true - y_pred) / y_true) * 100\n\ndef calculate_mae(y_true, y_pred):\n    \"\"\" Calculate mean absolute error (MAE)\"\"\"\n    return np.mean(np.abs(y_true - y_pred)) * 100\n\ndef calculate_rmse(y_true, y_pred):\n    \"\"\" Calculate root mean square error (RMSE)\"\"\"\n    return np.sqrt(np.mean((y_true - y_pred)**2))\n\ndef print_error_metrics(y_true, y_pred):\n    print('MAPE: %f'%calculate_mape(y_true, y_pred))\n    print('MPE: %f'%calculate_mpe(y_true, y_pred))\n    print('MAE: %f'%calculate_mae(y_true, y_pred))\n    print('RMSE: %f'%calculate_rmse(y_true, y_pred))\n    return\n\n\n# In[ ]:\n\n\nprint_error_metrics(y_true = df_prophet['y'], y_pred = fcst['yhat'])\n\n\n# # Let us model some time-series data! Finally! LSTM for regression\n# \n# We will be going through an example here.\n# \n# Also, here are some resources on recurrent neural networks (RNN) and Long Short-Term Memory networks (LSTMs):\n# * [Link 1](https://machinelearningmastery.com/time-series-prediction-lstm-recurrent-neural-networks-python-keras/)\n# * [Link 2](https://blog.statsbot.co/time-series-prediction-using-recurrent-neural-networks-lstms-807fa6ca7f)\n# * [Link 3](http://adventuresinmachinelearning.com/recurrent-neural-networks-lstm-tutorial-tensorflow/)\n\n# In[ ]:\n\n\ndef do_lstm_model(df, \n                  ts, \n                  look_back, \n                  epochs, \n                  type_ = None, \n                  train_fraction = 0.67):\n  \"\"\"\n   Create LSTM model\n   Source: https://machinelearningmastery.com/time-series-prediction-lstm-recurrent-neural-networks-python-keras/\n  \"\"\"\n  # Import packages\n  import numpy\n  import matplotlib.pyplot as plt\n  from pandas import read_csv\n  import math\n  from keras.models import Sequential\n  from keras.layers import Dense\n  from keras.layers import LSTM\n  from sklearn.preprocessing import MinMaxScaler\n  from sklearn.metrics import mean_squared_error\n\n  # Convert an array of values into a dataset matrix\n  def create_dataset(dataset, look_back=1):\n    \"\"\"\n    Create the dataset\n    \"\"\"\n    dataX, dataY = [], []\n    for i in range(len(dataset)-look_back-1):\n      a = dataset[i:(i+look_back), 0]\n      dataX.append(a)\n      dataY.append(dataset[i + look_back, 0])\n    return numpy.array(dataX), numpy.array(dataY)\n\n  # Fix random seed for reproducibility\n  numpy.random.seed(7)\n\n  # Get dataset\n  dataset = df[ts].values\n  dataset = dataset.astype('float32')\n\n  # Normalize the dataset\n  scaler = MinMaxScaler(feature_range=(0, 1))\n  dataset = scaler.fit_transform(dataset.reshape(-1, 1))\n  \n  # Split into train and test sets\n  train_size = int(len(dataset) * train_fraction)\n  test_size = len(dataset) - train_size\n  train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]\n  \n  # Reshape into X=t and Y=t+1\n  look_back = look_back\n  trainX, trainY = create_dataset(train, look_back)\n  testX, testY = create_dataset(test, look_back)\n  \n  # Reshape input to be [samples, time steps, features]\n  if type_ == 'regression with time steps':\n    trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))\n    testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1], 1))\n  elif type_ == 'stacked with memory between batches':\n    trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))\n    testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1], 1))\n  else:\n    trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))\n    testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1]))\n  \n  # Create and fit the LSTM network\n  batch_size = 1\n  model = Sequential()\n  \n  if type_ == 'regression with time steps':\n    model.add(LSTM(4, input_shape=(look_back, 1)))\n  elif type_ == 'memory between batches':\n    model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))\n  elif type_ == 'stacked with memory between batches':\n    model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True, return_sequences=True))\n    model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))\n  else:\n    model.add(LSTM(4, input_shape=(1, look_back)))\n  \n  model.add(Dense(1))\n  model.compile(loss='mean_squared_error', optimizer='adam')\n\n  if type_ == 'memory between batches' or type_ == 'stacked with memory between batches':\n    for i in range(100):\n      model.fit(trainX, trainY, epochs=1, batch_size=batch_size, verbose=2, shuffle=False)\n      model.reset_states()\n  else:\n    model.fit(trainX, \n              trainY, \n              epochs = epochs, \n              batch_size = 1, \n              verbose = 2)\n  \n  # Make predictions\n  if type_ == 'memory between batches' or type_ == 'stacked with memory between batches':\n    trainPredict = model.predict(trainX, batch_size=batch_size)\n    testPredict = model.predict(testX, batch_size=batch_size)\n  else:\n    trainPredict = model.predict(trainX)\n    testPredict = model.predict(testX)\n  \n  # Invert predictions\n  trainPredict = scaler.inverse_transform(trainPredict)\n  trainY = scaler.inverse_transform([trainY])\n  testPredict = scaler.inverse_transform(testPredict)\n  testY = scaler.inverse_transform([testY])\n  \n  # Calculate root mean squared error\n  trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))\n  print('Train Score: %.2f RMSE' % (trainScore))\n  testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0]))\n  print('Test Score: %.2f RMSE' % (testScore))\n  \n  # Shift train predictions for plotting\n  trainPredictPlot = numpy.empty_like(dataset)\n  trainPredictPlot[:, :] = numpy.nan\n  trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict\n  \n  # Shift test predictions for plotting\n  testPredictPlot = numpy.empty_like(dataset)\n  testPredictPlot[:, :] = numpy.nan\n  testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict\n  \n  # Plot baseline and predictions\n  plt.plot(scaler.inverse_transform(dataset))\n  plt.plot(trainPredictPlot)\n  plt.plot(testPredictPlot)\n  plt.show()\n  plt.close()\n  \n  return\n\n\n# In[ ]:\n\n\n# LSTM Network for Regression\ndo_lstm_model(df = df_prophet, \n              ts = 'y', \n              look_back = 1, \n              epochs = 5)\n\n# LSTM for Regression Using the Window Method\ndo_lstm_model(df = df_prophet, \n              ts = 'y', \n              look_back = 3, \n              epochs = 5)\n\n# LSTM for Regression with Time Steps\ndo_lstm_model(df = df_prophet, \n              ts = 'y', \n              look_back = 3, \n              epochs = 5, \n              type_ = 'regression with time steps')\n\n# # LSTM with Memory Between Batches\n# do_lstm_model(df = df_prophet, \n#               ts = 'y', \n#               look_back = 3, \n#               epochs = 5, \n#               type_ = 'memory between batches')\n\n# # Stacked LSTMs with Memory Between Batches\n# do_lstm_model(df = df_prophet, \n#               ts = 'y', \n#               look_back = 3, \n#               epochs = 5, \n#               type_ = 'stacked with memory between batches')\n\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "dcc573c40bed41b8c4b2da5db09a3bc5f0caeb62", "size": 34109, "ext": "py", "lang": "Python", "max_stars_repo_path": "PyData_LA_2018_Tutorial.py", "max_stars_repo_name": "MaximilianFreitag/JupyterNotebooks", "max_stars_repo_head_hexsha": "18a5e9fbea976e15b6cc9e997792b19259f6a118", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-08-04T15:31:32.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-22T21:00:11.000Z", "max_issues_repo_path": "PyData_LA_2018_Tutorial.py", "max_issues_repo_name": "MaximilianFreitag/JupyterNotebooks", "max_issues_repo_head_hexsha": "18a5e9fbea976e15b6cc9e997792b19259f6a118", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "PyData_LA_2018_Tutorial.py", "max_forks_repo_name": "MaximilianFreitag/JupyterNotebooks", "max_forks_repo_head_hexsha": "18a5e9fbea976e15b6cc9e997792b19259f6a118", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.0513565891, "max_line_length": 394, "alphanum_fraction": 0.6536984374, "include": true, "reason": "import numpy,from statsmodels", "num_tokens": 8725, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48828339529583464, "lm_q2_score": 0.14414884751767365, "lm_q1q2_score": 0.07038548869391123}}
{"text": "from sympy.core.containers import Tuple\nfrom sympy.core.singleton import S\nfrom sympy.core.symbol import Symbol\nfrom sympy.core.sympify import SympifyError\n\nfrom types import FunctionType\n\n\nclass TableForm:\n    r\"\"\"\n    Create a nice table representation of data.\n\n    Examples\n    ========\n\n    >>> from sympy import TableForm\n    >>> t = TableForm([[5, 7], [4, 2], [10, 3]])\n    >>> print(t)\n    5  7\n    4  2\n    10 3\n\n    You can use the SymPy's printing system to produce tables in any\n    format (ascii, latex, html, ...).\n\n    >>> print(t.as_latex())\n    \\begin{tabular}{l l}\n    $5$ & $7$ \\\\\n    $4$ & $2$ \\\\\n    $10$ & $3$ \\\\\n    \\end{tabular}\n\n    \"\"\"\n\n    def __init__(self, data, **kwarg):\n        \"\"\"\n        Creates a TableForm.\n\n        Parameters:\n\n            data ...\n                            2D data to be put into the table; data can be\n                            given as a Matrix\n\n            headings ...\n                            gives the labels for rows and columns:\n\n                            Can be a single argument that applies to both\n                            dimensions:\n\n                                - None ... no labels\n                                - \"automatic\" ... labels are 1, 2, 3, ...\n\n                            Can be a list of labels for rows and columns:\n                            The labels for each dimension can be given\n                            as None, \"automatic\", or [l1, l2, ...] e.g.\n                            [\"automatic\", None] will number the rows\n\n                            [default: None]\n\n            alignments ...\n                            alignment of the columns with:\n\n                                - \"left\" or \"<\"\n                                - \"center\" or \"^\"\n                                - \"right\" or \">\"\n\n                            When given as a single value, the value is used for\n                            all columns. The row headings (if given) will be\n                            right justified unless an explicit alignment is\n                            given for it and all other columns.\n\n                            [default: \"left\"]\n\n            formats ...\n                            a list of format strings or functions that accept\n                            3 arguments (entry, row number, col number) and\n                            return a string for the table entry. (If a function\n                            returns None then the _print method will be used.)\n\n            wipe_zeros ...\n                            Do not show zeros in the table.\n\n                            [default: True]\n\n            pad ...\n                            the string to use to indicate a missing value (e.g.\n                            elements that are None or those that are missing\n                            from the end of a row (i.e. any row that is shorter\n                            than the rest is assumed to have missing values).\n                            When None, nothing will be shown for values that\n                            are missing from the end of a row; values that are\n                            None, however, will be shown.\n\n                            [default: None]\n\n        Examples\n        ========\n\n        >>> from sympy import TableForm, Symbol\n        >>> TableForm([[5, 7], [4, 2], [10, 3]])\n        5  7\n        4  2\n        10 3\n        >>> TableForm([list('.'*i) for i in range(1, 4)], headings='automatic')\n          | 1 2 3\n        ---------\n        1 | .\n        2 | . .\n        3 | . . .\n        >>> TableForm([[Symbol('.'*(j if not i%2 else 1)) for i in range(3)]\n        ...            for j in range(4)], alignments='rcl')\n            .\n          . . .\n         .. . ..\n        ... . ...\n        \"\"\"\n        from sympy.matrices.dense import Matrix\n\n        # We only support 2D data. Check the consistency:\n        if isinstance(data, Matrix):\n            data = data.tolist()\n        _h = len(data)\n\n        # fill out any short lines\n        pad = kwarg.get('pad', None)\n        ok_None = False\n        if pad is None:\n            pad = \" \"\n            ok_None = True\n        pad = Symbol(pad)\n        _w = max(len(line) for line in data)\n        for i, line in enumerate(data):\n            if len(line) != _w:\n                line.extend([pad]*(_w - len(line)))\n            for j, lj in enumerate(line):\n                if lj is None:\n                    if not ok_None:\n                        lj = pad\n                else:\n                    try:\n                        lj = S(lj)\n                    except SympifyError:\n                        lj = Symbol(str(lj))\n                line[j] = lj\n            data[i] = line\n        _lines = Tuple(*[Tuple(*d) for d in data])\n\n        headings = kwarg.get(\"headings\", [None, None])\n        if headings == \"automatic\":\n            _headings = [range(1, _h + 1), range(1, _w + 1)]\n        else:\n            h1, h2 = headings\n            if h1 == \"automatic\":\n                h1 = range(1, _h + 1)\n            if h2 == \"automatic\":\n                h2 = range(1, _w + 1)\n            _headings = [h1, h2]\n\n        allow = ('l', 'r', 'c')\n        alignments = kwarg.get(\"alignments\", \"l\")\n\n        def _std_align(a):\n            a = a.strip().lower()\n            if len(a) > 1:\n                return {'left': 'l', 'right': 'r', 'center': 'c'}.get(a, a)\n            else:\n                return {'<': 'l', '>': 'r', '^': 'c'}.get(a, a)\n        std_align = _std_align(alignments)\n        if std_align in allow:\n            _alignments = [std_align]*_w\n        else:\n            _alignments = []\n            for a in alignments:\n                std_align = _std_align(a)\n                _alignments.append(std_align)\n                if std_align not in ('l', 'r', 'c'):\n                    raise ValueError('alignment \"%s\" unrecognized' %\n                        alignments)\n        if _headings[0] and len(_alignments) == _w + 1:\n            _head_align = _alignments[0]\n            _alignments = _alignments[1:]\n        else:\n            _head_align = 'r'\n        if len(_alignments) != _w:\n            raise ValueError(\n                'wrong number of alignments: expected %s but got %s' %\n                (_w, len(_alignments)))\n\n        _column_formats = kwarg.get(\"formats\", [None]*_w)\n\n        _wipe_zeros = kwarg.get(\"wipe_zeros\", True)\n\n        self._w = _w\n        self._h = _h\n        self._lines = _lines\n        self._headings = _headings\n        self._head_align = _head_align\n        self._alignments = _alignments\n        self._column_formats = _column_formats\n        self._wipe_zeros = _wipe_zeros\n\n    def __repr__(self):\n        from .str import sstr\n        return sstr(self, order=None)\n\n    def __str__(self):\n        from .str import sstr\n        return sstr(self, order=None)\n\n    def as_matrix(self):\n        \"\"\"Returns the data of the table in Matrix form.\n\n        Examples\n        ========\n\n        >>> from sympy import TableForm\n        >>> t = TableForm([[5, 7], [4, 2], [10, 3]], headings='automatic')\n        >>> t\n          | 1  2\n        --------\n        1 | 5  7\n        2 | 4  2\n        3 | 10 3\n        >>> t.as_matrix()\n        Matrix([\n        [ 5, 7],\n        [ 4, 2],\n        [10, 3]])\n        \"\"\"\n        from sympy.matrices.dense import Matrix\n        return Matrix(self._lines)\n\n    def as_str(self):\n        # XXX obsolete ?\n        return str(self)\n\n    def as_latex(self):\n        from .latex import latex\n        return latex(self)\n\n    def _sympystr(self, p):\n        \"\"\"\n        Returns the string representation of 'self'.\n\n        Examples\n        ========\n\n        >>> from sympy import TableForm\n        >>> t = TableForm([[5, 7], [4, 2], [10, 3]])\n        >>> s = t.as_str()\n\n        \"\"\"\n        column_widths = [0] * self._w\n        lines = []\n        for line in self._lines:\n            new_line = []\n            for i in range(self._w):\n                # Format the item somehow if needed:\n                s = str(line[i])\n                if self._wipe_zeros and (s == \"0\"):\n                    s = \" \"\n                w = len(s)\n                if w > column_widths[i]:\n                    column_widths[i] = w\n                new_line.append(s)\n            lines.append(new_line)\n\n        # Check heading:\n        if self._headings[0]:\n            self._headings[0] = [str(x) for x in self._headings[0]]\n            _head_width = max([len(x) for x in self._headings[0]])\n\n        if self._headings[1]:\n            new_line = []\n            for i in range(self._w):\n                # Format the item somehow if needed:\n                s = str(self._headings[1][i])\n                w = len(s)\n                if w > column_widths[i]:\n                    column_widths[i] = w\n                new_line.append(s)\n            self._headings[1] = new_line\n\n        format_str = []\n\n        def _align(align, w):\n            return '%%%s%ss' % (\n                (\"-\" if align == \"l\" else \"\"),\n                str(w))\n        format_str = [_align(align, w) for align, w in\n                      zip(self._alignments, column_widths)]\n        if self._headings[0]:\n            format_str.insert(0, _align(self._head_align, _head_width))\n            format_str.insert(1, '|')\n        format_str = ' '.join(format_str) + '\\n'\n\n        s = []\n        if self._headings[1]:\n            d = self._headings[1]\n            if self._headings[0]:\n                d = [\"\"] + d\n            first_line = format_str % tuple(d)\n            s.append(first_line)\n            s.append(\"-\" * (len(first_line) - 1) + \"\\n\")\n        for i, line in enumerate(lines):\n            d = [l if self._alignments[j] != 'c' else\n                 l.center(column_widths[j]) for j, l in enumerate(line)]\n            if self._headings[0]:\n                l = self._headings[0][i]\n                l = (l if self._head_align != 'c' else\n                     l.center(_head_width))\n                d = [l] + d\n            s.append(format_str % tuple(d))\n        return ''.join(s)[:-1]  # don't include trailing newline\n\n    def _latex(self, printer):\n        \"\"\"\n        Returns the string representation of 'self'.\n        \"\"\"\n        # Check heading:\n        if self._headings[1]:\n            new_line = []\n            for i in range(self._w):\n                # Format the item somehow if needed:\n                new_line.append(str(self._headings[1][i]))\n            self._headings[1] = new_line\n\n        alignments = []\n        if self._headings[0]:\n            self._headings[0] = [str(x) for x in self._headings[0]]\n            alignments = [self._head_align]\n        alignments.extend(self._alignments)\n\n        s = r\"\\begin{tabular}{\" + \" \".join(alignments) + \"}\\n\"\n\n        if self._headings[1]:\n            d = self._headings[1]\n            if self._headings[0]:\n                d = [\"\"] + d\n            first_line = \" & \".join(d) + r\" \\\\\" + \"\\n\"\n            s += first_line\n            s += r\"\\hline\" + \"\\n\"\n        for i, line in enumerate(self._lines):\n            d = []\n            for j, x in enumerate(line):\n                if self._wipe_zeros and (x in (0, \"0\")):\n                    d.append(\" \")\n                    continue\n                f = self._column_formats[j]\n                if f:\n                    if isinstance(f, FunctionType):\n                        v = f(x, i, j)\n                        if v is None:\n                            v = printer._print(x)\n                    else:\n                        v = f % x\n                    d.append(v)\n                else:\n                    v = printer._print(x)\n                    d.append(\"$%s$\" % v)\n            if self._headings[0]:\n                d = [self._headings[0][i]] + d\n            s += \" & \".join(d) + r\" \\\\\" + \"\\n\"\n        s += r\"\\end{tabular}\"\n        return s\n", "meta": {"hexsha": "4322924ff1c7218da7e6ea039da713506d66e342", "size": 11799, "ext": "py", "lang": "Python", "max_stars_repo_path": "sympy/printing/tableform.py", "max_stars_repo_name": "yupbank/sympy", "max_stars_repo_head_hexsha": "66d7aef9dc1b26055af22e27ba42004c40b95d7c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-19T03:38:42.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-19T03:38:42.000Z", "max_issues_repo_path": "sympy/printing/tableform.py", "max_issues_repo_name": "yupbank/sympy", "max_issues_repo_head_hexsha": "66d7aef9dc1b26055af22e27ba42004c40b95d7c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sympy/printing/tableform.py", "max_forks_repo_name": "yupbank/sympy", "max_forks_repo_head_hexsha": "66d7aef9dc1b26055af22e27ba42004c40b95d7c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.1498637602, "max_line_length": 79, "alphanum_fraction": 0.4385117383, "include": true, "reason": "from sympy", "num_tokens": 2818, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48047867804790706, "lm_q2_score": 0.14608725076600915, "lm_q1q2_score": 0.07019180912770517}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# In[1]:\n\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport scipy as sc\nimport pandas as pd\n\n\n# #  Lecture 7 -  Wells and aquifer\n# \n# ## Prof. Liedl/Prof. Werth/Prof. Chahar/Prabhas is to add the text contents.\n# ## Anne/Sophie is to add the numerical contents\n# \n# Include ipynb file for:\n# \n# Theis method.\n# \n# \n\n# ## Transmissivity ##\n\n# When discussing storage properties in Chapter / Lecture …, we saw that aquifers or single layers may frequently be treated as two-dimensional systems. This is justified because the lateral extension of aquifers is usually much larger than the vertical extension. Thus, vertical variations of storage properties can be replaced by some average value without adversely affecting the quantification of groundwater storage.\n# \n# Similar things can be done with regard to conductivity properties and this brings us to the geohydraulic parameter of **Transmissivity**. The idea is to neglect vertical variations of _hydraulic conductivity_ ($K$)  and to use vertically averaged values instead. This procedure does not eliminate horizontal variability, so _transmissivity_ may still depend on horizontal coordinates $(x, y)$.\n# \n# The vertically averaged $K$ value is then multiplied by the water-saturated thickness to obtain transmissivity. The concept of water-saturated thickness (or water-saturated depth) requires to distinguish whether _confined_ or _unconfined_ flow conditions prevail.\n# \n# In general, water-saturated thickness is the distance from the aquifer bottom to a level up to which all pores are filled with water. For _confined aquifers_, this level is equal to aquifer top and water-saturated thickness is tantamount to aquifer thickness. For _unconfined aquifers_, however, water-saturated thickness corresponds to the distance between aquifer bottom and groundwater level. We will see some illustrations below when we try to quantify _transmissivity_.\n# \n# The symbol $T$ is mostly used to denote transmissivity which has a dimension of $L^2T^{-1}$.\n# \n# \n\n# Let us have a closer look at the confined case first. The black cuboid in Fig.[LINK] illustrates that water-saturated thickness extends from aquifer bottom to aquifer top. So, it is equal to _aquifer thickness_ $m$. Transmissivity is calculated by\n# \n# $$\n# T_x = K_x \\cdot m  \\;\\; \\text{ and }  \\;\\; Ty = K_y \\cdot m\n# $$\n# \n# Here we allow for horizontal aquifer anisotropy with different hydraulic conductivities in $x-$ and $y-$ direction $(K_x \\neq K_y)$. \n# \n# For horizontally isotropic aquifers $(K_x = K_y = K)$, transmissivity is given by $T = K  \\cdot m $.\n# \n# <a href=\"fig1\"></a><img src=\"images/L7_f1.png\" alt =\"Transmissivity-Confined aquifer\" width = \"400\">\n# \n\n# In[2]:\n\n\nprint(\"We already have large text content, equations and so we can add a simple numerical example here\")\n\n\n# Things are a bit more complicated for _unconfined aquifers_. Fig. [LINK] illustrates that water-saturated thickness extends from the aquifer bottom to the groundwater table. It is important to note that _transmissivity_ of unconfined aquifers depends on the vertical position of the groundwater table. \n# \n# For instance, if the groundwater table is lowered during to a draught period, _transmissivity_ is decreasing. This is fundamentally different from the confined case where the water-saturated thickness is given by aquifer geometry only and is not affected by hydraulic head changes.\n# \n# <a href=\"fig2\"></a><img src=\"images/L7_f2.png\" alt =\"Transmissivity-unconfined aquifer\" width = \"400\">\n\n# Computing transmissivity of unconfined aquifers requires to determine the difference of hydraulic head h and the elevation of aquifer bottom $z_{bot}$. Based on this, transmissivity is given by:\n# \n# $$T_x = K_x \\cdot (h – z_{bot})$$ \n# and \n# $$T_y = K_y \\cdot (h – z_{bot})$$\n# \n# As above, we are allowing for horizontal aquifer anisotropy. For an isotropic unconfined aquifer we get \n# $$T = K\\cdot(h – z_{bot})$$\n\n# In[3]:\n\n\nprint(\"We already have large text content, equations and so we can add a simple numerical example here\")\n\n\n# Two more remarks appear to be appropriate: \n# \n# - First, _transmissivity_ may be computed by the given equations even if the aquifer bottom is not horizontal. This case is not covered by the figure above. \n# - Second, textbooks frequently present the equation $$ T = K\\cdot h $$ for transmissivity of unconfined aquifers. It is to be noted that this equation only holds if two conditions are fulfilled: \n# \n# - The aquifer bottom must be horizontal and \n# - hydraulic head values are expressed with respect to the elevation of aquifer bottom (= reference datum).\n# \n# \n# Finally, we can try to compute transmissivity for isotropic aquifers and check how the result depends on several quantities like aquifer bottom, aquifer top, and hydraulic head.\n# \n\n# In[4]:\n\n\n# A bit more complicated numerical example here. An example from Prof. Liedl - we improve further.\n\nprint(\"Q1. Determine if the aquifer is confined or unconfind and compute it's Transmissivity\")\n\n# input\n\nK = 8.5e-5 # m/s, hydraulic conductivity\nAb = 120 # m asl, aquifer bottom elevation \nAt = 150 # m asl, aquifer top elevation \nH  = 139 # m, hydraulic head\n\n#intermediate calculation\nA_T = At - Ab # m, Aquifer thickness\nS_T = np.minimum(A_T, (H - Ab))\n\n# Results\n\nif H < At:\n   print(\"\\n It is a unconfined aquifer\")\nelse:\n   print(\"\\n It is a Confined aquifer\")\n   \nT = K*A_T # m²/s, Transmissivity\n\nprint(\"\\nThe transmissivity is {0:0.2e} m\\u00b2/s\".format(T))\n\n\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "f03beeaa7b105aed496c3f68fe7d0922ba06d72f", "size": 5552, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/contents/flow/17_wells.py", "max_stars_repo_name": "prabhasyadav/iGW-I", "max_stars_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_build/jupyter_execute/contents/flow/17_wells.py", "max_issues_repo_name": "prabhasyadav/iGW-I", "max_issues_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/contents/flow/17_wells.py", "max_forks_repo_name": "prabhasyadav/iGW-I", "max_forks_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.0634920635, "max_line_length": 476, "alphanum_fraction": 0.7490994236, "include": true, "reason": "import numpy,import scipy", "num_tokens": 1416, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.45326186278634367, "lm_q2_score": 0.15405755686555633, "lm_q1q2_score": 0.06982841520119513}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.4'\n#       jupytext_version: 1.2.4\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# + {\"deletable\": true, \"editable\": true, \"cell_type\": \"markdown\"}\n# <div style='background-image: url(\"../../share/images/header.svg\") ; padding: 0px ; background-size: cover ; border-radius: 5px ; height: 250px'>\n#     <div style=\"float: right ; margin: 50px ; padding: 20px ; background: rgba(255 , 255 , 255 , 0.7) ; width: 50% ; height: 150px\">\n#         <div style=\"position: relative ; top: 50% ; transform: translatey(-50%)\">\n#             <div style=\"font-size: xx-large ; font-weight: 900 ; color: rgba(0 , 0 , 0 , 0.8) ; line-height: 100%\">Computational Seismology</div>\n#             <div style=\"font-size: large ; padding-top: 20px ; color: rgba(0 , 0 , 0 , 0.5)\">Reproducible Papers - Syngine Paper</div>\n#         </div>\n#     </div>\n# </div>\n\n# + {\"deletable\": true, \"editable\": true, \"cell_type\": \"markdown\"}\n# ---\n#\n# # Figure 8: Education\n#\n# This notebook is part of the supplementary materials for the Syngine paper and reproduces figure 8.\n#\n# This notebook creates the phase relative times figure. Requires matplotlib >= 1.5 and an ObsPy version (>= 1.0) with the syngine client.\n#\n# ##### Authors:\n# * Lion Krischer ([@krischer](https://github.com/krischer))\n\n# + {\"deletable\": true, \"editable\": true}\n# %matplotlib inline\n\nimport obspy\nimport numpy as np\n\nfrom obspy.clients.syngine import Client\n\nimport itertools\n\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.basemap import Basemap\nplt.style.use(\"seaborn-paper\")\n\n# + {\"deletable\": true, \"editable\": true}\nc = Client()\n\n# + {\"deletable\": true, \"editable\": true}\n# Get seismograms for various strike values.\n_d_plane_crossing = []\n\nfor strike in np.linspace(85, 95, 11):\n    print(strike)\n    _d_plane_crossing.append((strike, c.get_waveforms(model=\"ak135f_5s\",\n        receiverlatitude=0.0, receiverlongitude=0.0,\n        sourcelatitude=0.0, sourcelongitude=30.0, components=\"Z\", units=\"velocity\",\n        sourcedepthinmeters=0.0, sourcedoublecouple=[strike, 90.0, 0.0])[0]))\n    \n\n# + {\"deletable\": true, \"editable\": true}\nmax_amp = max(np.abs(_i[1].data).max() for _i in _d_plane_crossing)\n\nfor _i, tr in enumerate(_d_plane_crossing):\n    plt.plot(tr[1].data / max_amp + _i)\nplt.xlim(1300, 2100)\nplt.show()\n\n# + {\"deletable\": true, \"editable\": true}\n_d_depth = []\n\n# Get seismograms for various depths.\nfor depth in [10, 20, 30, 40, 50, 100, 200]:\n    print(depth)\n    _d_depth.append((depth, c.get_waveforms(model=\"ak135f_5s\",\n        receiverlatitude=0.0, receiverlongitude=0.0,\n        sourcelatitude=0.0, sourcelongitude=30.0, components=\"Z\", units=\"velocity\",\n        sourcedepthinmeters=depth * 1000, sourcemomenttensor=[1E20, 0, 0, 0, 0, 0])[0]))    \n\n# + {\"deletable\": true, \"editable\": true}\nmax_amp = max(np.abs(_i[1].data).max() for _i in _d_depth)\n\nfor _i, tr in enumerate(_d_depth):\n    plt.plot(tr[1].data / max_amp + _i * 0.5)\nplt.xlim(0, 6000)\nplt.show()\n\n# + {\"deletable\": true, \"editable\": true}\n# Plot everything.\nplt.figure(figsize=(8, 3))\n\nplt.subplot(121)\n\nmax_amp = max(np.abs(_i[1].data).max() for _i in _d_plane_crossing)\n\nticks = []\nlabels = []\n\nfor _i, tr in enumerate(_d_plane_crossing):\n    plt.plot(tr[1].times(), tr[1].data / max_amp * 200.4 + _i, color=\"0.1\")\n    ticks.append(_i)\n    labels.append(\"%i\" % (90.0 - tr[0]))\nplt.xlim(345, 460)\nplt.text(360, 10.8, \"P Phase\", size=\"small\")\nplt.text(403, 10.8, \"PP Phase\", size=\"small\")\nplt.ylim(-2, 12)\nplt.xlabel(\"Time since origin [s]\")\nplt.ylabel(\"$\\Delta_{strike}$ from nodal plane [degree]\")\nplt.yticks(ticks, labels)\n\nplt.subplot(122)\nmax_amp = max(np.abs(_i[1].data).max() for _i in _d_depth)\n\ncolors = [\"0.7\", \"0.1\", \"0.4\", \"0.1\", \"0.1\", \"0.1\", \"0.1\"]\n\nticks = []\nlabels = []\nfor _i, tr in enumerate(_d_depth):\n    plt.plot(tr[1].times(), tr[1].data / max_amp * 14.0 + _i, color=colors[_i])\n    ticks.append(_i)\n    labels.append(\"%i\" % (tr[0]))\nplt.xlim(0, 1500)\nplt.gca().yaxis.tick_right()\nplt.xlabel(\"Time since origin [s]\")\nplt.gca().yaxis.set_label_position(\"right\")\nplt.ylabel(\"Event depth [km]\")\nplt.yticks(ticks, labels)\nplt.tight_layout()\nplt.ylim(-1, 7)\nplt.savefig(\"education.pdf\")\nplt.show()\n# -\n\n\n", "meta": {"hexsha": "d5f17e107bc23b90a029637b3c6bb45482d05363", "size": 4346, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks/Reproducible Papers/Syngine_2016/figure_8_education.py", "max_stars_repo_name": "krischer/seismo_live_build", "max_stars_repo_head_hexsha": "e4e8e59d9bf1b020e13ac91c0707eb907b05b34f", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-07-11T10:01:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-16T14:26:03.000Z", "max_issues_repo_path": "notebooks/Reproducible Papers/Syngine_2016/figure_8_education.py", "max_issues_repo_name": "krischer/seismo_live_build", "max_issues_repo_head_hexsha": "e4e8e59d9bf1b020e13ac91c0707eb907b05b34f", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "notebooks/Reproducible Papers/Syngine_2016/figure_8_education.py", "max_forks_repo_name": "krischer/seismo_live_build", "max_forks_repo_head_hexsha": "e4e8e59d9bf1b020e13ac91c0707eb907b05b34f", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-11-11T05:05:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-12T09:36:24.000Z", "avg_line_length": 31.0428571429, "max_line_length": 147, "alphanum_fraction": 0.6481822365, "include": true, "reason": "import numpy", "num_tokens": 1414, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4765796659321433, "lm_q2_score": 0.1460872396128689, "lm_q1q2_score": 0.06962220785165003}}
{"text": "# -*- coding: utf-8 -*-\n# Copyright (C) 2020-2021 by SCICO Developers\n# All rights reserved. BSD 3-clause License.\n# This file is part of the SCICO package. Details of the copyright and\n# user license can be found in the 'LICENSE' file distributed with the\n# package.\n\n\"\"\"Random number generation.\n\nThis module provides convenient wrappers around several `jax.random\n<https://jax.readthedocs.io/en/stable/jax.random.html>`_ routines to handle\nthe generation and splitting of PRNG keys, as well as the generation of random\n:class:`.BlockArray`.\n\n::\n\n   # Calls to scico.random functions always return a PRNG key\n   # If no key is passed to the function, a new key is generated\n   x, key = scico.random.randn((2,))\n   print(x)   # [ 0.19307713 -0.52678305]\n\n   # scico.random functions automatically split the PRNGkey and return\n   # an updated key\n   y, key = scico.random.randn((2,), key=key)\n   print(y) # [ 0.00870693 -0.04888531]\n\nThe user is responsible for passing the PRNG key to :mod:`scico.random` functions.\nIf no key is passed, repeated calls to :mod:`scico.random` functions will return the same\nrandom numbers:\n\n::\n\n   x, key = scico.random.randn((2,))\n   print(x)   # [ 0.19307713 -0.52678305]\n\n   # No key passed, will return the same random numbers!\n   y, key = scico.random.randn((2,))\n   print(y)   # [ 0.19307713 -0.52678305]\n\n\nIf the desired shape is a tuple containing tuples, a :class:`.BlockArray` is returned:\n\n::\n\n   x, key = scico.random.randn( ((1, 1), (2,)), key=key)\n   print(x)  # scico.blockarray.BlockArray:\n             # DeviceArray([ 1.1378784 , -1.220955  , -0.59153646], dtype=float32)\n\n\"\"\"\n\n__author__ = \"\"\"Luke Pfister <pfister@lanl.gov>\"\"\"\n\nimport functools\nimport inspect\nimport sys\nfrom typing import Optional, Tuple, Union\n\nimport numpy as np\n\nimport jax\n\nfrom scico.blockarray import BlockArray, block_sizes\nfrom scico.typing import BlockShape, DType, JaxArray, PRNGKey, Shape\nfrom scico.util import is_nested\n\n\ndef _add_seed(fun):\n    \"\"\"\n    Modifies a jax.random function to add a `seed` argument.\n\n    Args:\n        fun: function to be modified, e.g., jax.random.normal. Expects `key`\n        to be the first argument.\n\n    Returns:\n        fun_alt: a version of `fun` supporting an optional `seed` argument that\n        is used to create a `jax.random.PRNGKey` that is passed along as the `key`.\n        The `key` argument may still be used, but is moved to be second-to-last.\n        By default, `seed=0`. The `seed` argument is added last. Other arguments are unchanged.\n    \"\"\"\n\n    # find number of arguments to fun\n    num_params = len(inspect.signature(fun).parameters)\n\n    def fun_alt(*args, key=None, seed=None, **kwargs):\n\n        # key and seed may be in *args, look for them\n        if len(args) >= num_params:  # they passed all position args including key\n            key = args[num_params - 1]\n        if len(args) > num_params:  # they passed all position args including key and seed\n            seed = args[num_params]\n\n        if key is not None and seed is not None:\n            raise ValueError(\"Key and seed cannot both be specified\")\n\n        if key is None:\n            if seed is None:\n                seed = 0\n            key = jax.random.PRNGKey(seed)\n\n        result = fun(key, *args[: num_params - 1], **kwargs)\n\n        key, subkey = jax.random.split(key, 2)\n        return result, key\n\n    lines = fun.__doc__.split(\"\\n\\n\")\n    fun_alt.__doc__ = \"\\n\\n\".join(\n        lines[0:1]\n        + [\n            f\"  Wrapped version of `jax.random.{fun.__name__} <https://jax.readthedocs.io/en/stable/jax.random.html#jax.random.{fun.__name__}>`_. \"\n            \"The SCICO version of this function moves the `key` argument to the end of the argument list, \"\n            \"adds an additional `seed` argument after that, and allows the `shape` argument \"\n            \"to accept a nested list, in which case a `BlockArray` is returned. \"\n            \"Always returns a `(result, key)` tuple.\",\n            \"  Original docstring below.\",\n        ]\n        + lines[1:]\n    )\n\n    return fun_alt\n\n\ndef _allow_block_shape(fun):\n    \"\"\"\n    Decorates a jax.random function so that the `shape` argument may be a BlockShape.\n    \"\"\"\n\n    # use inspect to find which argument number is `shape`\n    shape_ind = list(inspect.signature(fun).parameters.keys()).index(\"shape\")\n\n    @functools.wraps(fun)\n    def fun_alt(*args, **kwargs):\n\n        # get the shape argument if it was passed\n        if len(args) > shape_ind:\n            shape = args[shape_ind]\n        elif \"shape\" in kwargs:\n            shape = kwargs[\"shape\"]\n        else:  # shape was not passed, call fun as normal\n            return fun(*args, **kwargs)\n\n        # if shape is not nested, call fun as normal\n        if not is_nested(shape):\n            return fun(*args, **kwargs)\n        # shape is nested, so make a BlockArray!\n\n        # call the wrapped fun with an shape=(size,)\n        subargs = list(args)\n        subkwargs = kwargs.copy()\n        size = np.sum(block_sizes(shape))\n\n        if len(subargs) > shape_ind:\n            subargs[shape_ind] = (size,)\n        else:  # shape must be a kwarg if not a positional arg\n            subkwargs[\"shape\"] = (size,)\n\n        result_flat = fun(*subargs, **subkwargs)\n\n        return BlockArray.array_from_flattened(result_flat, shape)\n\n    return fun_alt\n\n\ndef _wrap(fun):\n    fun_wrapped = _add_seed(_allow_block_shape(fun))\n    fun_wrapped.__module__ = __name__  # so it appears in docs\n    return fun_wrapped\n\n\nexceptions = [  # these do not take key and shape\n    \"PRNGKey\",\n    \"double_sided_maxwell\",\n    \"fold_in\",\n    \"permutation\",\n    \"shuffle\",\n    \"split\",\n    \"weibull_min\",\n    \"threefry_2x32\",\n]\n\nfunc_names = [\n    t[0] for t in inspect.getmembers(jax.random, inspect.isfunction) if t[0] not in exceptions\n]\n\nfor name in func_names:\n    setattr(sys.modules[__name__], name, _wrap(getattr(jax.random, name)))\n\n\ndef randn(\n    shape: Union[Shape, BlockShape],\n    dtype: DType = np.float32,\n    key: Optional[PRNGKey] = None,\n    seed: Optional[int] = None,\n) -> Tuple[Union[JaxArray, BlockArray], PRNGKey]:\n    \"\"\"Return an array drawn from the standard normal distribution. Alias for :func:`scico.random.normal`.\n\n    Args:\n        shape:  Shape of output array.  If shape is a tuple, a DeviceArray is returned.\n            If shape is a tuple of tuples, a :class:`.BlockArray` is returned.\n        key:  JAX PRNGKey.  Defaults to None, in which case a new key\n              is created using the seed arg.\n        seed: Seed for new PRNGKey. Default: 0\n        dtype: dtype for returned value.  Default to float32.  If np.complex64,\n               generates an array sampled from complex normal distribution.\n\n    Returns:\n        tuple: A tuple (x, key) containing:\n\n           - **x** : (DeviceArray):  Generated random array\n           - **key** : Updated random PRNGKey.\n    \"\"\"\n    return normal(shape, dtype, key, seed)\n", "meta": {"hexsha": "734dfe2881261a1be02ef6325a3d2e4e6ba6d1a5", "size": 6916, "ext": "py", "lang": "Python", "max_stars_repo_path": "scico/random.py", "max_stars_repo_name": "lukepfister/scico", "max_stars_repo_head_hexsha": "c849c4fa6089b99d9a4dec520c9a04cca426d2d7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "scico/random.py", "max_issues_repo_name": "lukepfister/scico", "max_issues_repo_head_hexsha": "c849c4fa6089b99d9a4dec520c9a04cca426d2d7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scico/random.py", "max_forks_repo_name": "lukepfister/scico", "max_forks_repo_head_hexsha": "c849c4fa6089b99d9a4dec520c9a04cca426d2d7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.4694835681, "max_line_length": 147, "alphanum_fraction": 0.6427125506, "include": true, "reason": "import numpy,import jax", "num_tokens": 1802, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49609382947091946, "lm_q2_score": 0.14033624949008322, "lm_q1q2_score": 0.06961994742312175}}
{"text": "# coding: utf-8\n\n# ----------------------------------------------------------------------------\n\n# Disciplina Tópicos Especiais II (C318) \n\n# Curso: Fundamentos de Machine Learning \n\n# Professor: Ricardo Augusto\n\n# ----------------------------------------------------------------------------\n\n# Projeto de Machine Learning\n\n# Tema: Predição de despesas médicas por meio de Regressão Linear\n\n# Grupo: Emanuel Massafera Magalhães, Pedro Henrique de Almeida e Thiago Santos da Costa\n\n#%% Formulação e Definição do Problema de ML\n\n# Frame the problem and look at the big picture.\n\n# i) Enquadramento do problema de ML - Aprendizagem Supervisionada\n\n# ii) Trata-se de um problema de regressão (variável de saída: despesas médicas de pacientes dos Estados Unidos)\n\n# iii) Regressão Múltipla: uma vez que o sistema de ML precisa lidar com várias características (features) para gerar uma predição\n\n# iv) Regressão Univariada: uma vez que estamos gerando a predição de um único valor para a variável de saída (um valor por paciente)\n\n# v)  Se estamos fazendo a predição de múltiplos valores para a variável de saída temos uma regressão multivariada\n\n# vi) Não há fluxo contínuo de dados entrando no sistema de ML a ser desenvolvido - com isso não há necessidade de ajuste-rápido aos dados (online learning))\n\n# vii) A quantidade de dados pode ser acomodada na memória (batch learning)\n\n#%% Estrutura do Projeto de ML\n\n# - Estrutura do projeto   \n#   - Importação de bibiliotecas utilizadas\n#   - Importação da base de dados\n#   - Manipulações iniciais nos dados\n#   - Criação de conjuntos de dados de treino e teste\n#   - Investigando Correlações\n#   - Preparação dos dados para Modelagem \n#   - Limpeza dos dados\n#   - Manipulando features categóricas\n#   - Feature Scaling - Pipeline de transformação\n#   - Criando o modelo de regressão linear\n#   - Avaliação de Desempenho - Evaluation\n#   - Validação Cruzada\n#   - Usando o modelo nos dados de teste\n\n#%% Bibliotecas utilizadas no projeto\n\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n#%% Importação da base de dados\n\n# Importando dados (arquivo .csv) a partir da URL (fonte)\nurl = 'https://raw.githubusercontent.com/stedy/Machine-Learning-with-R-datasets/master/insurance.csv'\ndf  = pd.read_csv(url)\n\n# Salvando no diretório do projeto\ndf.to_csv('insurance.csv')\n\n# Informações sobre o dataframe (atributo info)\ndf.info()\n\n# ---------------------------\n# Informações sobre o dataset\n\n# 1. age: Número inteiro que indica a idade do beneficiário principal (excluindo acima de 64 anos, uma vez que são geralmente cobertos pelo governo).\n\n# 2. sex: Gênero do segurado, podendo ser homem ou mulher.\n\n# 3. bmi: Numero que indica o Índice de Massa Corporal (IMC) de segurado. É uma medida internacional utilizada para determinar se uma pessoa está no peso ideal. O IMC é calculado como sendo peso (em quilogramas) dividido pela altura (em metros) ao quadrado. Um IMC ideal está dentro do faixa de 18,5 a 24,9.\n\n# 4. children: Número inteiro que indica o número de filhos ou dependentes cobertos pelo plano de seguro do segurado.\n\n# 5. smoker: Indica se o segurado regularmente fuma tabaco ou não.\n\n# 6. region: Indica o local de residência do beneficiário nos EUA, dividido em quatro regiões geográficas: nordeste, sudeste, sudoeste ou noroeste.\n\n# 7. charges: Variável dependente que representa o valor de despesas médicas.\n\n#%% Manipulações iniciais nos dados\n\n# Descrição estatística do dataframe Pandas\ndf_stats = df.describe()\ndf_stats\n\n# Extração de informações de estatística descritiva do dataframe:\n# Ex: 25% dos pacientes tem idade (mediana) até 27 anos\n# Ex: 75% dos pacientes tem idade (mediana) até 51 anos\n# Ex: A idade média dos pacientes é de 39 anos\n# Ex: O valor médio do bmi é de 30.66 kg/m²\n# Ex: O valor médio dos gastos médicos medianos é de 13270 dólares\n\n# ----------------------------------------------------------------------------\n# Acessando e Manipulando o dataframe\n\n# Indexação por rótulo - selecionando uma série Pandas a partir do dataframe\ndf['age']\n\n# Indexação por rótulo - selecionando mais de uma série Pandas a partir do dataframe\ndf[['age', 'bmi']]\n\n# Usando a notação ponto (.) para acesso à series de um dataframe\ndf.age\n\n# Verificando a variável categórica - sex\ngêneros = df['sex'].value_counts()\ngêneros\n\n# Verificando a variável categórica - smoker\nfumantes = df['smoker'].value_counts()\nfumantes\n\n# Verificando a variável categórica - smoker\nregiões = df['region'].value_counts()\nregiões\n\n# Visualizando histogramas relacionados com todas as variáveis do dataframe\ndf.hist(bins=50)\nplt.show()\n\n# Visualizando histogramas das variáveis - características - features\ndf['age'].hist(bins = 50)\nplt.xlabel('age')\nplt.ylabel('count')\n\ndf['bmi'].hist(bins = 50)\nplt.xlabel('bmi')\nplt.ylabel('count')\n\ndf['children'].hist(bins = 50)\nplt.xlabel('children')\nplt.ylabel('count')\n\ndf['charges'].hist(bins=50)\nplt.xlabel('charges')\nplt.ylabel('count')\n\n# Biblioteca para análise de dados (visualizações estatísticas)\nimport klib\nklib.dist_plot(df['age'])\nklib.dist_plot(df['charges'])\nklib.dist_plot(df['bmi'])\nklib.dist_plot(df['children'])\n\n# ----------------------------------------------------------------------------\n# Análise conduzida a partir dos histogramas \n\n# i) A grande maioria dos indivíduos em nossos dados tem despesas médicas \n# anuais entre zero e US $ 15.000, embora a cauda da distribuição se estenda\n# muito além desses picos. Como a regressão linear assume uma distribuição \n# normal para a variável dependente, essa distribuição não é ideal.\n\n# ii) Outro problema em mãos é que os modelos de regressão exigem que todos\n# os recursos sejam numéricos, mas temos três features (sex, region e smoker) \n# que não são numéricas.\n\n# ----------------------------------------------------------------------------\n\n#%% Criação de conjuntos de dados de treino e teste \n\n# Método de Amostragem Aleatória Simples (Sklearn)\nfrom sklearn.model_selection import train_test_split\n\n# Função do scikit-learn train_test_split\ntrain_set, test_set = train_test_split(df, test_size = 0.2, random_state = 42)\n\n#%% Investigando Correlações\n\n# Criando uma cópia do dataset de treino\ninsurance = train_set.copy()\n\n# Fazendo a estimativa da matriz de correlação das variáveis do dataframe\ncorrelation_matrix = insurance.corr()\ncorrelation_matrix\n\nklib.corr_plot(insurance)\nklib.corr_plot(insurance, target='charges')\n\n# Gráfico usando plt.scatter\nx = insurance['age']\ny = insurance['charges']\nplt.scatter(x,y, alpha = 0.05)\nplt.xlabel('age')\nplt.ylabel('charges')\nplt.title('ScatterPlot - age vs charges')\nplt.grid()\n\nx = insurance['bmi']\ny = insurance['charges']\nplt.scatter(x,y, alpha = 0.05)\nplt.xlabel('bmi')\nplt.ylabel('charges')\nplt.title('ScatterPlot - bmi vs charges')\nplt.grid()\n\n# Checando qual é o valor do coeficiente de correlação (Person)\n# computado entre cada feature (variável) e a característica/variável charges\ncorrelation_matrix['charges']\n\n# Colocando as correlações em ordem ascendente\ncorrelation_matrix['charges'].sort_values(ascending = False)\n\n# Função scatter_matrix (Pandas): forma alternativa de checagem da matriz de correlação \nfrom pandas.plotting import scatter_matrix\n\n# Selecionando atributos (features) de interesse para uso da scatter_matrix\nattributes = ['charges', \n              'age', \n              'bmi',\n              'children']\n# Função scatter_matrix: plot na forma de matriz contendo gráficos de dispersão\nscatter_matrix(insurance[attributes], figsize=(12, 8))\n\n# Análise: aparentemente, a feature age tem relação estatística\n# significativa (alta correlação) com os gastos médicos\n\n#%% Preparação dos Dados para Modelagem\n\n# Criando uma cópia do dataset de treino e removendo a variável target charges\ninsurance = train_set.drop('charges', axis = 1)\n\n# Criando uma série para a variável de saída (target) \ninsurance_labels = train_set['charges'].copy()\n\n#%% Limpeza dos Dados (Data Cleaning)\n\nklib.missingval_plot(insurance)\n\n# Não há valores faltantes no dataset\n\n#%% Manipulando features categóricas\n\n# Checando informações do dataset\ninsurance.info()\n\ninsurance_num = insurance.drop(['sex', 'smoker', 'region'], axis=1)\ninsurance_cat = insurance[['sex', 'smoker', 'region']]\ninsurance_cat.head(10)\n\n# Aplicando OneHotEncoder para fazer a codificação (encoding) das\n# variáveis sex, smoker e region\nfrom sklearn.preprocessing import OneHotEncoder\n\n# Criando encoder\ncat_encoder = OneHotEncoder()\n\n# Fazendo o fit (estimação de parâmetros) e transform (transformando os dados)\ninsurance_cat_1hot = cat_encoder.fit_transform(insurance_cat)\ninsurance_cat_1hot\n\n# A saída é uma matriz esparsa (sparse matrix) - sparse matrix only stores \n# the location of the nonzero elements\n# Podemos converter para um array NumPy\ninsurance_cat_1hot.toarray()\n\n# Lista de atributos das categorias\ncat_encoder.categories_\n\n#%% Feature Scaling - Pipeline de transformação\n\nfrom sklearn.pipeline import Pipeline\nfrom sklearn.impute import SimpleImputer\nfrom sklearn.preprocessing import StandardScaler\nnum_pipeline = Pipeline([\n    ('imputer', SimpleImputer(strategy='median')),\n    ('std_scaler', StandardScaler()),\n    ])\n\nfrom sklearn.compose import ColumnTransformer\nnum_attribs = list(insurance_num)\ncat_attribs = ['sex', 'smoker', 'region']\n\nfull_pipeline = ColumnTransformer([\n    ('num', num_pipeline, num_attribs),\n    ('cat', OneHotEncoder(), cat_attribs),\n    ])\n\ninsurance_prepared = full_pipeline.fit_transform(insurance)\n\n#%% Modelagem\n\nfrom sklearn.linear_model import LinearRegression\n\nlin_reg = LinearRegression()\nlin_reg.fit(insurance_prepared, insurance_labels)\n\n#%% Avaliação de Desempenho - Evaluation\n\n# ----------------------------------------------------------------------------\n# Avaliação de desempenho com todos os dados (sem separação de treino e teste)\n\nfrom sklearn.metrics import mean_squared_error\ninsurance_predictions = lin_reg.predict(insurance_prepared)\nlin_mse = mean_squared_error(insurance_labels, insurance_predictions)\nlin_rmse = np.sqrt(lin_mse)\nlin_rmse\n\n# ----------------------------------------------------------------------------\n# Avaliação de desempenho com separação de treino e teste\nfrom sklearn.model_selection import train_test_split\n\n# Matriz de Features X\nX = insurance_prepared\n\n# Variáveç Target\ny = insurance_labels\n\n# Divisão de treino e teste (sklearn) - train_test_split\n\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, \n                                                    random_state=42)\n\nlin_mse = mean_squared_error(insurance_labels, insurance_predictions)\nlin_rmse = np.sqrt(lin_mse)\nlin_rmse\n\n#%% Validação Cruzada\n\nfrom sklearn.model_selection import cross_val_score\n\ndef display_scores(scores):\n    print('Scores:', scores)\n    print('Mean:', scores.mean())\n    print('Standard deviation:', scores.std())\n    \nlin_scores = cross_val_score(lin_reg, insurance_prepared, insurance_labels,\nscoring='neg_mean_squared_error', cv=10)\nlin_rmse_scores = np.sqrt(-lin_scores)\ndisplay_scores(lin_rmse_scores)\n\nr2_train = lin_reg.score(insurance_prepared, insurance_labels)\nprint('R2 no set de treino: %.2f' % r2_train)\n\n#%% Usando o modelo nos dados de teste\n\ninsurance_test = test_set.drop('charges', axis = 1)\ninsurance_test_labels = test_set['charges'].copy()\n\ninsurance_test_prepared = full_pipeline.fit_transform(insurance_test)\n\nlin_scores = cross_val_score(lin_reg, insurance_test_prepared, insurance_test_labels,\nscoring='neg_mean_squared_error', cv=10)\nlin_rmse_scores = np.sqrt(-lin_scores)\ndisplay_scores(lin_rmse_scores)\n\nr2_test = lin_reg.score(insurance_test_prepared, insurance_test_labels)\nprint('R2 no set de teste: %.2f' % r2_test)\n", "meta": {"hexsha": "48b8893799b1115b952571e16f7a381b15445960", "size": 11662, "ext": "py", "lang": "Python", "max_stars_repo_path": "script.py", "max_stars_repo_name": "emanuelmassafera/projeto-C318", "max_stars_repo_head_hexsha": "133af33aa5c26ddaf25a6a1219c6b036d90612e3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-12-12T23:39:32.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-12T23:39:32.000Z", "max_issues_repo_path": "script.py", "max_issues_repo_name": "emanuelmassafera/projeto-C318", "max_issues_repo_head_hexsha": "133af33aa5c26ddaf25a6a1219c6b036d90612e3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "script.py", "max_forks_repo_name": "emanuelmassafera/projeto-C318", "max_forks_repo_head_hexsha": "133af33aa5c26ddaf25a6a1219c6b036d90612e3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.6666666667, "max_line_length": 307, "alphanum_fraction": 0.725090036, "include": true, "reason": "import numpy", "num_tokens": 2963, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46879062662624377, "lm_q2_score": 0.14804719991116141, "lm_q1q2_score": 0.06940313961661414}}
{"text": "\"\"\"\nAxioms\n\nThis documentation covers how to implement axioms and proceeds with an\noverview of the implementation of the axiom infrastructure. It assumes\nthat the reader is familiar with the :ref:`category primer\n<sage.categories.primer>`, and in particular its :ref:`section about\naxioms <category-primer-axioms>`.\n\nImplementing axioms\n===================\n\nSimple case involving a single predefined axiom\n-----------------------------------------------\n\nSuppose that one wants to provide code (and documentation, tests, ...)\nfor the objects of some existing category ``Cs()`` that satisfy some\npredefined axiom ``A``.\n\nThe first step is to open the hood and check whether there already\nexists a class implementing the category ``Cs().A()``. For example,\ntaking ``Cs=Semigroups`` and the ``Finite`` axiom, there already\nexists a class for the category of finite semigroups::\n\n    sage: Semigroups().Finite()\n    Category of finite semigroups\n    sage: type(Semigroups().Finite())\n    <class 'sage.categories.finite_semigroups.FiniteSemigroups_with_category'>\n\nIn this case, we say that the category of semigroups *implements* the\naxiom ``Finite``, and code about finite semigroups should go in the\nclass :class:`FiniteSemigroups` (or, as usual, in its nested classes\n``ParentMethods``, ``ElementMethods``, and so on).\n\nOn the other hand, there is no class for the category of infinite\nsemigroups::\n\n    sage: Semigroups().Infinite()\n    Category of infinite semigroups\n    sage: type(Semigroups().Infinite())\n    <class 'sage.categories.category.JoinCategory_with_category'>\n\nThis category is indeed just constructed as the intersection of the\ncategories of semigroups and of infinite sets respectively::\n\n    sage: Semigroups().Infinite().super_categories()\n    [Category of semigroups, Category of infinite sets]\n\nIn this case, one needs to create a new class to implement the axiom\n``Infinite`` for this category. This boils down to adding a nested\nclass ``Semigroups.Infinite`` inheriting from :class:`CategoryWithAxiom`.\n\nIn the following example, we implement a category ``Cs``, with a\nsubcategory for the objects satisfying the ``Finite`` axiom defined in\nthe super category ``Sets`` (we will see later on how to *define* new\naxioms)::\n\n    sage: from sage.categories.category_with_axiom import CategoryWithAxiom\n    sage: class Cs(Category):\n    ....:     def super_categories(self):\n    ....:         return [Sets()]\n    ....:     class Finite(CategoryWithAxiom):\n    ....:         class ParentMethods:\n    ....:             def foo(self):\n    ....:                 print(\"I am a method on finite C's\")\n\n::\n\n    sage: Cs().Finite()\n    Category of finite cs\n    sage: Cs().Finite().super_categories()\n    [Category of finite sets, Category of cs]\n    sage: Cs().Finite().all_super_categories()\n    [Category of finite cs, Category of finite sets,\n     Category of cs, Category of sets, ...]\n    sage: Cs().Finite().axioms()\n    frozenset({'Finite'})\n\nNow a parent declared in the category ``Cs().Finite()`` inherits from\nall the methods of finite sets and of finite `C`'s, as desired::\n\n    sage: P = Parent(category=Cs().Finite())\n    sage: P.is_finite()             # Provided by Sets.Finite.ParentMethods\n    True\n    sage: P.foo()                   # Provided by Cs.Finite.ParentMethods\n    I am a method on finite C's\n\n.. _category-with-axiom-design:\n\n.. NOTE::\n\n    - This follows the same idiom as for\n      :ref:`sage.categories.covariant_functorial_construction`.\n\n    - From an object oriented point of view, any subcategory ``Cs()``\n      of :class:`Sets` inherits a ``Finite`` method.  Usually ``Cs``\n      could complement this method by overriding it with a method\n      ``Cs.Finite`` which would make a super call to ``Sets.Finite``\n      and then do extra stuff.\n\n      In the above example, ``Cs`` also wants to complement\n      ``Sets.Finite``, though not by doing more stuff, but by\n      providing it with an additional mixin class containing the code\n      for finite ``Cs``. To keep the analogy, this mixin class is to\n      be put in ``Cs.Finite``.\n\n    - By defining the axiom ``Finite``, :class:`Sets` fixes the\n      semantic of ``Cs.Finite()`` for all its subcategories ``Cs``:\n      namely \"the category of ``Cs`` which are finite as sets\". Hence,\n      for example, ``Modules.Free.Finite`` cannot be used to model the\n      category of free modules of finite rank, even though their\n      traditional name \"finite free modules\" might suggest it.\n\n    - It may come as a surprise that we can actually use the same name\n      ``Finite`` for the mixin class and for the method defining the\n      axiom; indeed, by default a class does not have a binding\n      behavior and would completely override the method. See the\n      section :ref:`axioms-defining-a-new-axiom` for details and the\n      rationale behind it.\n\n      An alternative would have been to give another name to the mixin\n      class, like ``FiniteCategory``. However this would have resulted\n      in more namespace pollution, whereas using ``Finite`` is already\n      clear, explicit, and easier to remember.\n\n    - Under the hood, the category ``Cs().Finite()`` is aware that it\n      has been constructed from the category ``Cs()`` by adding the\n      axiom ``Finite``::\n\n        sage: Cs().Finite().base_category()\n        Category of cs\n        sage: Cs().Finite()._axiom\n        'Finite'\n\nOver time, the nested class ``Cs.Finite`` may become large and too\ncumbersome to keep as a nested subclass of ``Cs``. Or the category with\naxiom may have a name of its own in the literature, like *semigroups*\nrather than *associative magmas*, or *fields* rather than *commutative\ndivision rings*. In this case, the category with axiom can be put\nelsewhere, typically in a separate file, with just a link from\n``Cs``::\n\n    sage: class Cs(Category):\n    ....:     def super_categories(self):\n    ....:         return [Sets()]\n    sage: class FiniteCs(CategoryWithAxiom):\n    ....:     class ParentMethods:\n    ....:         def foo(self):\n    ....:             print(\"I am a method on finite C's\")\n    sage: Cs.Finite = FiniteCs\n    sage: Cs().Finite()\n    Category of finite cs\n\nFor a real example, see the code of the class :class:`FiniteGroups` and the\nlink to it in :class:`Groups`. Note that the link is implemented using\n:class:`~sage.misc.lazy_import.LazyImport`; this is highly recommended: it\nmakes sure that :class:`FiniteGroups` is imported after :class:`Groups` it\ndepends upon, and makes it explicit that the class :class:`Groups` can be\nimported and is fully functional without importing :class:`FiniteGroups`.\n\n.. NOTE::\n\n    Some categories with axioms are created upon Sage's startup. In such a\n    case, one needs to pass the ``at_startup=True`` option to\n    :class:`~sage.misc.lazy_import.LazyImport`, in order to quiet the warning\n    about that lazy import being resolved upon startup. See for example\n    ``Sets.Finite``.\n\n    This is undoubtedly a code smell. Nevertheless, it is preferable\n    to stick to lazy imports, first to resolve the import order\n    properly, and more importantly as a reminder that the category\n    would be best not constructed upon Sage's startup. This is to spur\n    developers to reduce the number of parents (and therefore\n    categories) that are constructed upon startup. Each\n    ``at_startup=True`` that will be removed will be a measure of\n    progress in this direction.\n\n.. NOTE::\n\n    In principle, due to a limitation of\n    :class:`~sage.misc.lazy_import.LazyImport` with nested classes (see\n    :trac:`15648`), one should pass the option ``as_name`` to\n    :class:`~sage.misc.lazy_import.LazyImport`::\n\n        Finite = LazyImport('sage.categories.finite_groups', 'FiniteGroups', as_name='Finite')\n\n    in order to prevent ``Groups.Finite`` to keep on reimporting\n    ``FiniteGroups``.\n\n    Given that passing this option introduces some redundancy and is\n    error prone, the axiom infrastructure includes a little workaround\n    which makes the ``as_name`` unnecessary in this case.\n\nMaking the category with axiom directly callable\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nIf desired, a category with axiom can be constructed directly through\nits class rather than through its base category::\n\n    sage: Semigroups()\n    Category of semigroups\n    sage: Semigroups() is Magmas().Associative()\n    True\n\n    sage: FiniteGroups()\n    Category of finite groups\n    sage: FiniteGroups() is Groups().Finite()\n    True\n\nFor this notation to work, the class :class:`Semigroups` needs to be\naware of the base category class (here, :class:`Magmas`) and of the\naxiom (here, ``Associative``)::\n\n    sage: Semigroups._base_category_class_and_axiom\n    (<class 'sage.categories.magmas.Magmas'>, 'Associative')\n    sage: Fields._base_category_class_and_axiom\n    (<class 'sage.categories.division_rings.DivisionRings'>, 'Commutative')\n    sage: FiniteGroups._base_category_class_and_axiom\n    (<class 'sage.categories.groups.Groups'>, 'Finite')\n    sage: FiniteDimensionalAlgebrasWithBasis._base_category_class_and_axiom\n    (<class 'sage.categories.algebras_with_basis.AlgebrasWithBasis'>, 'FiniteDimensional')\n\nIn our example, the attribute ``_base_category_class_and_axiom`` was\nset upon calling ``Cs().Finite()``, which makes the notation seemingly\nwork::\n\n    sage: FiniteCs()\n    Category of finite cs\n    sage: FiniteCs._base_category_class_and_axiom\n    (<class '__main__.Cs'>, 'Finite')\n    sage: FiniteCs._base_category_class_and_axiom_origin\n    'set by __classget__'\n\nBut calling ``FiniteCs()`` right after defining the class would have\nfailed (try it!). In general, one needs to set the attribute explicitly::\n\n    sage: class FiniteCs(CategoryWithAxiom):\n    ....:     _base_category_class_and_axiom = (Cs, 'Finite')\n    ....:     class ParentMethods:\n    ....:         def foo(self):\n    ....:             print(\"I am a method on finite C's\")\n\nHaving to set explicitly this link back from ``FiniteCs`` to ``Cs``\nintroduces redundancy in the code. It would therefore be desirable to\nhave the infrastructure set the link automatically instead (a\ndifficulty is to achieve this while supporting lazy imported\ncategories with axiom).\n\nAs a first step, the link is set automatically upon accessing the\nclass from the base category class::\n\n    sage: Algebras.WithBasis._base_category_class_and_axiom\n    (<class 'sage.categories.algebras.Algebras'>, 'WithBasis')\n    sage: Algebras.WithBasis._base_category_class_and_axiom_origin\n    'set by __classget__'\n\nHence, for whatever this notation is worth, one can currently do::\n\n    sage: Algebras.WithBasis(QQ)\n    Category of algebras with basis over Rational Field\n\nWe don't recommend using syntax like ``Algebras.WithBasis(QQ)``, as it\nmay eventually be deprecated.\n\nAs a second step, Sage tries some obvious heuristics to deduce the link\nfrom the name of the category with axiom (see\n:func:`base_category_class_and_axiom` for the details). This typically\ncovers the following examples::\n\n    sage: FiniteGroups()\n    Category of finite groups\n    sage: FiniteGroups() is Groups().Finite()\n    True\n    sage: FiniteGroups._base_category_class_and_axiom_origin\n    'deduced by base_category_class_and_axiom'\n\n    sage: FiniteDimensionalAlgebrasWithBasis(QQ)\n    Category of finite dimensional algebras with basis over Rational Field\n    sage: FiniteDimensionalAlgebrasWithBasis(QQ) is Algebras(QQ).FiniteDimensional().WithBasis()\n    True\n\nIf the heuristic succeeds, the result is guaranteed to be correct. If\nit fails, typically because the category has a name of its own like\n:class:`Fields`, the attribute ``_base_category_class_and_axiom``\nshould be set explicitly. For more examples, see the code of the\nclasses :class:`Semigroups` or :class:`Fields`.\n\n.. NOTE::\n\n    When printing out a category with axiom, the heuristic determines\n    whether a category has a name of its own by checking out how\n    ``_base_category_class_and_axiom`` was set::\n\n        sage: Fields._base_category_class_and_axiom_origin\n        'hardcoded'\n\n    See :meth:`CategoryWithAxiom._without_axioms`,\n    :meth:`CategoryWithAxiom._repr_object_names_static`.\n\nIn our running example ``FiniteCs``, Sage failed to deduce\nautomatically the base category class and axiom because the class\n``Cs`` is not in the standard location ``sage.categories.cs``.\n\n.. TOPIC:: Design discussion\n\n    The above deduction, based on names, is undoubtedly inelegant. But\n    it's safe (either the result is guaranteed to be correct, or an\n    error is raised), it saves on some redundant information, and it\n    is only used for the simple shorthands like ``FiniteGroups()`` for\n    ``Groups().Finite()``. Finally, most if not all of these\n    shorthands are likely to eventually disappear (see :trac:`15741`\n    and the :ref:`related discussion in the primer\n    <category-primer-axioms-single-entry-point>`).\n\n.. _axioms-defining-a-new-axiom:\n\nDefining a new axiom\n--------------------\n\nWe describe now how to define a new axiom. The first step is to figure\nout the largest category where the axiom makes sense. For example\n``Sets`` for ``Finite``, ``Magmas`` for ``Associative``, or\n``Modules`` for ``FiniteDimensional``. Here we define the axiom\n``Green`` for the category ``Cs`` and its subcategories::\n\n    sage: from sage.categories.category_with_axiom import CategoryWithAxiom\n    sage: class Cs(Category):\n    ....:     def super_categories(self):\n    ....:         return [Sets()]\n    ....:     class SubcategoryMethods:\n    ....:         def Green(self):\n    ....:             '<documentation of the axiom Green>'\n    ....:             return self._with_axiom(\"Green\")\n    ....:     class Green(CategoryWithAxiom):\n    ....:         class ParentMethods:\n    ....:             def foo(self):\n    ....:                 print(\"I am a method on green C's\")\n\nWith the current implementation, the name of the axiom must also be\nadded to a global container::\n\n    sage: all_axioms = sage.categories.category_with_axiom.all_axioms\n    sage: all_axioms += (\"Green\",)\n\nWe can now use the axiom as usual::\n\n    sage: Cs().Green()\n    Category of green cs\n\n    sage: P = Parent(category=Cs().Green())\n    sage: P.foo()\n    I am a method on green C's\n\nCompared with our first example, the only newcomer is the method\n``.Green()`` that can be used by any subcategory ``Ds()`` of ``Cs()``\nto add the axiom ``Green``. Note that the expression ``Ds().Green``\nalways evaluates to this method, regardless of whether ``Ds`` has a\nnested class ``Ds.Green`` or not (an implementation detail)::\n\n    sage: Cs().Green\n    <bound method Cs_with_category.Green of Category of cs>\n\nThanks to this feature (implemented in :meth:`CategoryWithAxiom.__classget__`),\nthe user is systematically referred to the documentation of this\nmethod when doing introspection on ``Ds().Green``::\n\n    sage: C = Cs()\n    sage: C.Green?             # not tested\n    sage: Cs().Green.__doc__\n    '<documentation of the axiom Green>'\n\nIt is therefore the natural spot for the documentation of the axiom.\n\n.. NOTE::\n\n    The presence of the nested class ``Green`` in ``Cs`` is currently\n    mandatory even if it is empty.\n\n.. TODO::\n\n    Specify whether or not one should systematically use\n    @cached_method in the definition of the axiom. And make sure all\n    the definition of axioms in Sage are consistent in this respect!\n\n.. TODO::\n\n    We could possibly define an @axiom decorator? This could hide two\n    little implementation details: whether or not to make the method a\n    cached method, and the call to _with_axiom(...) under the hood. It\n    could do possibly do some more magic. The gain is not obvious though.\n\n.. NOTE::\n\n    ``all_axioms`` is only used marginally, for sanity checks and when\n    trying to derive automatically the base category class. The order\n    of the axioms in this tuple also controls the order in which they\n    appear when printing out categories with axioms (see\n    :meth:`CategoryWithAxiom._repr_object_names_static`).\n\n    During a Sage session, new axioms should only be added at the *end*\n    of ``all_axioms``, as above, so as to not break the cache of\n    :func:`axioms_rank`. Otherwise, they can be inserted statically\n    anywhere in the tuple. For axioms defined within the Sage library,\n    the name is best inserted by editing directly the definition of\n    ``all_axioms`` in :mod:`sage.categories.category_with_axiom`.\n\n.. TOPIC:: Design note\n\n    Let us state again that, unlike what the existence of\n    ``all_axioms`` might suggest, the definition of an axiom is local\n    to a category and its subcategories. In particular, two\n    independent categories ``Cs()`` and ``Ds()`` can very well define\n    axioms with the same name and different semantics. As long as the\n    two hierarchies of subcategories don't intersect, this is not a\n    problem. And if they do intersect naturally (that is if one is\n    likely to create a parent belonging to both categories), this\n    probably means that the categories ``Cs`` and ``Ds`` are about\n    related enough areas of mathematics that one should clear the\n    ambiguity by having either the same semantic or different names.\n\n    This caveat is no different from that of name clashes in hierarchy\n    of classes involving multiple inheritance.\n\n.. TODO::\n\n    Explore ways to get rid of this global ``all_axioms`` tuple,\n    and/or have automatic registration there, and/or having a\n    register_axiom(...) method.\n\nSpecial case: defining an axiom depending on several categories\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nIn some cases, the largest category where the axiom makes sense is the\nintersection of two categories. This is typically the case for axioms\nspecifying compatibility conditions between two otherwise unrelated\noperations, like ``Distributive`` which specifies a compatibility\nbetween `*` and `+`. Ideally, we would want the ``Distributive`` axiom\nto be defined by::\n\n    sage: Magmas() & AdditiveMagmas()\n    Join of Category of magmas and Category of additive magmas\n\nThe current infrastructure does not support this perfectly: indeed,\ndefining an axiom for a category `C` requires `C` to have a class of\nits own; hence a :class:`~.category.JoinCategory` as above won't do;\nwe need to implement a new class like\n:class:`~.magmas_and_additive_magmas.MagmasAndAdditiveMagmas`;\nfurthermore, we cannot yet model the fact that ``MagmasAndAdditiveMagmas()``\n*is* the intersection of ``Magmas()`` and ``AdditiveMagmas()`` rather than a\nmere subcategory::\n\n    sage: from sage.categories.magmas_and_additive_magmas import MagmasAndAdditiveMagmas\n    sage: Magmas() & AdditiveMagmas() is MagmasAndAdditiveMagmas()\n    False\n    sage: Magmas() & AdditiveMagmas()             # todo: not implemented\n    Category of magmas and additive magmas\n\nStill, there is a workaround to get the natural notations::\n\n    sage: (Magmas() & AdditiveMagmas()).Distributive()\n    Category of distributive magmas and additive magmas\n    sage: (Monoids() & CommutativeAdditiveGroups()).Distributive()\n    Category of rings\n\nThe trick is to define ``Distributive`` as usual in\n:class:`~.magmas_and_additive_magmas.MagmasAndAdditiveMagmas`, and to\nadd a method :meth:`Magmas.SubcategoryMethods.Distributive` which\nchecks that ``self`` is a subcategory of both ``Magmas()`` and\n``AdditiveMagmas()``, complains if not, and otherwise takes the\nintersection of ``self`` with ``MagmasAndAdditiveMagmas()`` before\ncalling ``Distributive``.\n\nThe downsides of this workaround are:\n\n- Creation of an otherwise empty class\n  :class:`~.magmas_and_additive_magmas.MagmasAndAdditiveMagmas`.\n\n- Pollution of the namespace of ``Magmas()`` (and subcategories like\n  ``Groups()``) with a method that is irrelevant (but safely complains\n  if called).\n\n- ``C._with_axiom('Distributive')`` is not strictly equivalent to\n  ``C.Distributive()``, which can be unpleasantly surprising::\n\n    sage: (Monoids() & CommutativeAdditiveGroups()).Distributive()\n    Category of rings\n\n    sage: (Monoids() & CommutativeAdditiveGroups())._with_axiom('Distributive')\n    Join of Category of monoids and Category of commutative additive groups\n\n.. TODO::\n\n    Other categories that would be better implemented via an axiom\n    depending on a join category include:\n\n    - :class:`Algebras`: defining an associative unital algebra as a\n      ring and a module satisfying the suitable compatibility axiom\n      between inner multiplication and multiplication by scalars\n      (bilinearity). Of course this should be implemented at the level\n      of :class:`~.magmatic_algebras.MagmaticAlgebras`, if not higher.\n\n    - :class:`Bialgebras`: defining an bialgebra as an algebra and\n      coalgebra where the coproduct is a morphism for the product.\n\n    - :class:`Bimodules`: defining a bimodule as a left and right\n      module where the two actions commute.\n\n.. TODO::\n\n    - Design and implement an idiom for the definition of an axiom by a join\n      category.\n\n    - Or support more advanced joins, through some hook or registration\n      process to specify that a given category *is* the intersection of two\n      (or more) categories.\n\n    - Or at least improve the above workaround to avoid the last issue; this\n      possibly could be achieved using a class ``Magmas.Distributive`` with a\n      bit of ``__classcall__`` magic.\n\nHandling multiple axioms, arborescence structure of the code\n------------------------------------------------------------\n\nPrelude\n^^^^^^^\n\nLet us consider the category of magmas, together with two of its\naxioms, namely ``Associative`` and ``Unital``. An associative magma is\na *semigroup* and a unital semigroup is a *monoid*. We have also seen\nthat axioms commute::\n\n    sage: Magmas().Unital()\n    Category of unital magmas\n    sage: Magmas().Associative()\n    Category of semigroups\n    sage: Magmas().Associative().Unital()\n    Category of monoids\n    sage: Magmas().Unital().Associative()\n    Category of monoids\n\nAt the level of the classes implementing these categories, the\nfollowing comes as a general naturalization of the previous section::\n\n    sage: Magmas.Unital\n    <class 'sage.categories.magmas.Magmas.Unital'>\n    sage: Magmas.Associative\n    <class 'sage.categories.semigroups.Semigroups'>\n    sage: Magmas.Associative.Unital\n    <class 'sage.categories.monoids.Monoids'>\n\nHowever, the following may look suspicious at first::\n\n    sage: Magmas.Unital.Associative\n    Traceback (most recent call last):\n    ...\n    AttributeError: type object 'Magmas.Unital' has no attribute 'Associative'\n\nThe purpose of this section is to explain the design of the code\nlayout and the rationale for this mismatch.\n\nAbstract model\n^^^^^^^^^^^^^^\n\nAs we have seen in the :ref:`Primer <category-primer-axioms-explosion>`,\nthe objects of a category ``Cs()`` can usually satisfy, or not, many\ndifferent axioms. Out of all combinations of axioms, only a small\nnumber are relevant in practice, in the sense that we actually want to\nprovide features for the objects satisfying these axioms.\n\nTherefore, in the context of the category class ``Cs``, we want to\nprovide the system with a collection `(D_S)_{S\\in \\mathcal S}` where\neach `S` is a subset of the axioms and the corresponding `D_S` is a\nclass for the subcategory of the objects of ``Cs()`` satisfying the\naxioms in `S`. For example, if ``Cs()`` is the category of magmas, the\npairs `(S, D_S)` would include::\n\n    {Associative}                 : Semigroups\n    {Associative, Unital}         : Monoids\n    {Associative, Unital, Inverse}: Groups\n    {Associative, Commutative}    : Commutative Semigroups\n    {Unital,      Inverse}        : Loops\n\nThen, given a subset `T` of axioms, we want the system to be able to\nselect automatically the relevant classes\n`(D_S)_{S\\in \\mathcal S, S\\subset T}`,\nand build from them a category for the objects of ``Cs`` satisfying\nthe axioms in `T`, together with its hierarchy of super categories. If\n`T` is in the indexing set `\\mathcal S`, then the class of the\nresulting category is directly `D_T`::\n\n    sage: C = Magmas().Unital().Inverse().Associative(); C\n    Category of groups\n    sage: type(C)\n    <class 'sage.categories.groups.Groups_with_category'>\n\nOtherwise, we get a join category::\n\n    sage: C = Magmas().Infinite().Unital().Associative(); C\n    Category of infinite monoids\n    sage: type(C)\n    <class 'sage.categories.category.JoinCategory_with_category'>\n    sage: C.super_categories()\n    [Category of monoids, Category of infinite sets]\n\nConcrete model as an arborescence of nested classes\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nWe further want the construction to be efficient and amenable to\nlaziness. This led us to the following design decision: the collection\n`(D_S)_{S\\in \\mathcal S}` of classes should be structured as an\narborescence (or equivalently a *rooted forest*). The root is ``Cs``,\ncorresponding to `S=\\emptyset`. Any other class `D_S` should be the\nchild of a single class `D_{S'}` where `S'` is obtained from `S` by\nremoving a single axiom `A`. Of course, `D_{S'}` and `A` are\nrespectively the base category class and axiom of the category with\naxiom `D_S` that we have met in the first section.\n\nAt this point, we urge the reader to explore the code of\n:class:`Magmas` and\n:class:`~.distributive_magmas_and_additive_magmas.DistributiveMagmasAndAdditiveMagmas`\nand see how the arborescence structure on the categories with axioms\nis reflected by the nesting of category classes.\n\nDiscussion of the design\n^^^^^^^^^^^^^^^^^^^^^^^^\n\nPerformance\n~~~~~~~~~~~\n\nThanks to the arborescence structure on subsets of axioms,\nconstructing the hierarchy of categories and computing intersections\ncan be made efficient with, roughly speaking, a linear/quadratic\ncomplexity in the size of the involved category hierarchy multiplied\nby the number of axioms (see Section :ref:`axioms-algorithmic`). This\nis to be put in perspective with the manipulation of arbitrary\ncollections of subsets (aka boolean functions) which can easily raise\nNP-hard problems.\n\nFurthermore, thanks to its locality, the algorithms can be made\nsuitably lazy: in particular, only the involved category classes need\nto be imported.\n\nFlexibility\n~~~~~~~~~~~\n\nThis design also brings in quite some flexibility, with the\npossibility to support features such as defining new axioms depending\non other axioms and deduction rules. See below.\n\nAsymmetry\n~~~~~~~~~\n\nAs we have seen at the beginning of this section, this design\nintroduces an asymmetry. It's not so bad in practice, since in most\npractical cases, we want to work incrementally. It's for example more\nnatural to describe :class:`FiniteFields` as :class:`Fields` with the\naxiom ``Finite`` rather than :class:`Magmas` and\n:class:`AdditiveMagmas` with all (or at least sufficiently many) of\nthe following axioms::\n\n    sage: sorted(Fields().axioms())\n    ['AdditiveAssociative', 'AdditiveCommutative', 'AdditiveInverse',\n     'AdditiveUnital', 'Associative', 'Commutative', 'Distributive',\n     'Division', 'NoZeroDivisors', 'Unital']\n\nThe main limitation is that the infrastructure currently imposes to be\nincremental by steps of a single axiom.\n\nIn practice, among the roughly 60 categories with axioms that are\ncurrently implemented in Sage, most admitted a (rather) natural choice\nof a base category and single axiom to add. For example, one usually\nthinks more naturally of a monoid as a semigroup which is unital\nrather than as a unital magma which is associative. Modeling this\nasymmetry in the code actually brings a bonus: it is used for printing\nout categories in a (heuristically) mathematician-friendly way::\n\n    sage: Magmas().Commutative().Associative()\n    Category of commutative semigroups\n\nOnly in a few cases is a choice made that feels mathematically\narbitrary. This is essentially in the chain of nested classes\n:class:`.distributive_magmas_and_additive_magmas.DistributiveMagmasAndAdditiveMagmas.AdditiveAssociative.AdditiveCommutative.AdditiveUnital.Associative`.\n\nPlaceholder classes\n~~~~~~~~~~~~~~~~~~~\n\nGiven that we can only add a single axiom at a time when implementing\na :class:`CategoryWithAxiom`, we need to create a few category classes\nthat are just placeholders. For the worst example, see the chain of\nnested classes\n:class:`.distributive_magmas_and_additive_magmas.DistributiveMagmasAndAdditiveMagmas.AdditiveAssociative.AdditiveCommutative.AdditiveUnital.Associative`.\n\nThis is suboptimal, but fits within the scope of the axiom\ninfrastructure which is to reduce a potentially exponential number of\nplaceholder category classes to just a couple.\n\nNote also that, in the above example, it's likely that some of the\nintermediate classes will grow to non placeholder ones, as people will\nexplore more weaker variants of rings.\n\nMismatch between the arborescence of nested classes and the hierarchy of categories\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe fact that the hierarchy relation between categories is not\nreflected directly as a relation between the classes may sound\nsuspicious at first! However, as mentioned in the primer, this is\nactually a big selling point of the axioms infrastructure: by\ncalculating automatically the hierarchy relation between categories\nwith axioms one avoids the nightmare of maintaining it by hand.\nInstead, only a rather minimal number of links needs to be maintainted\nin the code (one per category with axiom).\n\nBesides, with the flexibility introduced by runtime deduction rules\n(see below), the hierarchy of categories may depend on the parameters\nof the categories and not just their class. So it's fine to make it\nclear from the onset that the two relations do not match.\n\nEvolutivity\n~~~~~~~~~~~\n\nAt this point, the arborescence structure has to be hardcoded by hand\nwith the annoyances we have seen. This does not preclude, in a future\niteration, to design and implement some idiom for categories with\naxioms that adds several axioms at once to a base category; maybe some\nvariation around::\n\n    class DistributiveMagmasAndAdditiveMagmas:\n        ...\n\n        @category_with_axiom(\n            AdditiveAssociative,\n            AdditiveCommutative,\n            AdditiveUnital,\n            AdditiveInverse,\n            Associative)\n        def _(): return LazyImport('sage.categories.rngs', 'Rngs', at_startup=True)\n\nor::\n\n    register_axiom_category(DistributiveMagmasAndAdditiveMagmas,\n                            {AdditiveAssociative,\n                             AdditiveCommutative,\n                             AdditiveUnital,\n                             AdditiveInverse,\n                             Associative},\n                            'sage.categories.rngs', 'Rngs', at_startup=True)\n\nThe infrastructure would then be in charge of building the appropriate\narborescence under the hood. Or rely on some database (see discussion\non :trac:`10963`, in particular at the end of comment 332).\n\nAxioms defined upon other axioms\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nSometimes an axiom can only be defined when some other axiom\nholds. For example, the axiom ``NoZeroDivisors`` only makes sense if\nthere is a zero, that is if the axiom ``AdditiveUnital`` holds. Hence,\nfor the category\n:class:`~.magmas_and_additive_magmas.MagmasAndAdditiveMagmas`, we\nconsider in the abstract model only those subsets of axioms where the\npresence of ``NoZeroDivisors`` implies that of ``AdditiveUnital``.  We\nalso want the axiom to be only available if meaningful::\n\n    sage: Rings().NoZeroDivisors()\n    Category of domains\n    sage: Rings().Commutative().NoZeroDivisors()\n    Category of integral domains\n    sage: Semirings().NoZeroDivisors()\n    Traceback (most recent call last):\n    ...\n    AttributeError: 'Semirings_with_category' object has no attribute 'NoZeroDivisors'\n\nConcretely, this is to be implemented by defining the new axiom in the\n(``SubcategoryMethods`` nested class of the) appropriate category with\naxiom. For example the axiom ``NoZeroDivisors`` would be naturally\ndefined in\n:class:`.magmas_and_additive_magmas.MagmasAndAdditiveMagmas.Distributive.AdditiveUnital`.\n\n.. NOTE::\n\n    The axiom ``NoZeroDivisors`` is currently defined in\n    :class:`Rings`, by simple lack of need for the feature; it should\n    be lifted up as soon as relevant, that is when some code will be\n    available for parents with no zero divisors that are not\n    necessarily rings.\n\n.. _axioms-deduction-rules:\n\nDeduction rules\n^^^^^^^^^^^^^^^\n\nA similar situation is when an axiom ``A`` of a category ``Cs``\nimplies some other axiom ``B``, with the same consequence as above on\nthe subsets of axioms appearing in the abstract model. For example, a\ndivision ring necessarily has no zero divisors::\n\n    sage: 'NoZeroDivisors' in Rings().Division().axioms()\n    True\n    sage: 'NoZeroDivisors' in Rings().axioms()\n    False\n\nThis deduction rule is implemented by the method\n:meth:`Rings.Division.extra_super_categories`::\n\n    sage: Rings().Division().extra_super_categories()\n    (Category of domains,)\n\nIn general, this is to be implemented by a method\n``Cs.A.extra_super_categories`` returning a tuple ``(Cs().B(),)``, or\npreferably ``(Ds().B(),)`` where ``Ds`` is the category defining the\naxiom ``B``.\n\nThis follows the same idiom as for deduction rules about functorial\nconstructions (see :meth:`.covariant_functorial_construction.CovariantConstructionCategory.extra_super_categories`).\nFor example, the fact that a Cartesian product of associative magmas\n(i.e. of semigroups) is an associative magma is implemented in\n:meth:`Semigroups.CartesianProducts.extra_super_categories`::\n\n    sage: Magmas().Associative()\n    Category of semigroups\n    sage: Magmas().Associative().CartesianProducts().extra_super_categories()\n    [Category of semigroups]\n\nSimilarly, the fact that the algebra of a commutative magma is\ncommutative is implemented in\n:meth:`Magmas.Commutative.Algebras.extra_super_categories`::\n\n    sage: Magmas().Commutative().Algebras(QQ).extra_super_categories()\n    [Category of commutative magmas]\n\n.. WARNING::\n\n    In some situations this idiom is inapplicable as it would require\n    to implement two classes for the same category. This is the\n    purpose of the next section.\n\nSpecial case\n~~~~~~~~~~~~\n\nIn the previous examples, the deduction rule only had an influence on\nthe super categories of the category with axiom being constructed. For\nexample, when constructing ``Rings().Division()``, the rule\n:meth:`Rings.Division.extra_super_categories` simply adds\n``Rings().NoZeroDivisors()`` as a super category thereof.\n\nIn some situations this idiom is inapplicable because a class for the\ncategory with axiom under construction already exists elsewhere. Take\nfor example Wedderburn's theorem: any finite division ring is\ncommutative, i.e. is a finite field. In other words,\n``DivisionRings().Finite()`` *coincides* with ``Fields().Finite()``::\n\n        sage: DivisionRings().Finite()\n        Category of finite fields\n        sage: DivisionRings().Finite() is Fields().Finite()\n        True\n\nTherefore we cannot create a class ``DivisionRings.Finite`` to hold\nthe desired ``extra_super_categories`` method, because there is\nalready a class for this category with axiom, namely\n``Fields.Finite``.\n\nA natural idiom would be to have ``DivisionRings.Finite`` be a link to\n``Fields.Finite`` (locally introducing an undirected cycle in the\narborescence of nested classes). It would be a bit tricky to implement\nthough, since one would need to detect, upon constructing\n``DivisionRings().Finite()``, that ``DivisionRings.Finite`` is\nactually ``Fields.Finite``, in order to construct appropriately\n``Fields().Finite()``; and reciprocally, upon computing the super\ncategories of ``Fields().Finite()``, to not try to add\n``DivisionRings().Finite()`` as a super category.\n\nInstead the current idiom is to have a method\n``DivisionRings.Finite_extra_super_categories`` which mimicks the\nbehavior of the would-be\n``DivisionRings.Finite.extra_super_categories``::\n\n    sage: DivisionRings().Finite_extra_super_categories()\n    (Category of commutative magmas,)\n\nThis idiom is admittedly rudimentary, but consistent with how\nmathematical facts specifying non trivial inclusion relations between\ncategories are implemented elsewhere in the various\n``extra_super_categories`` methods of axiom categories and covariant\nfunctorial constructions. Besides, it gives a natural spot (the\ndocstring of the method) to document and test the modeling of the\nmathematical fact. Finally, Wedderburn's theorem is arguably a theorem\nabout division rings (in the context of division rings, finiteness\nimplies commutativity) and therefore lives naturally in\n:class:`DivisionRings`.\n\nAn alternative would be to implement the category of finite division\nrings (i.e. finite fields) in a class ``DivisionRings.Finite`` rather\nthan ``Fields.Finite``::\n\n    sage: from sage.categories.category_with_axiom import CategoryWithAxiom\n\n    sage: class MyDivisionRings(Category):\n    ....:     def super_categories(self):\n    ....:         return [Rings()]\n\n    sage: class MyFields(Category):\n    ....:     def super_categories(self):\n    ....:         return [MyDivisionRings()]\n\n    sage: class MyFiniteFields(CategoryWithAxiom):\n    ....:     _base_category_class_and_axiom = (MyDivisionRings, \"Finite\")\n    ....:     def extra_super_categories(self): # Wedderburn's theorem\n    ....:         return [MyFields()]\n\n    sage: MyDivisionRings.Finite = MyFiniteFields\n\n    sage: MyDivisionRings().Finite()\n    Category of my finite fields\n    sage: MyFields().Finite() is MyDivisionRings().Finite()\n    True\n\nIn general, if several categories ``C1s()``, ``C2s()``, ... are mapped to\nthe same category when applying some axiom ``A`` (that is ``C1s().A()\n== C2s().A() == ...``), then one should be careful to implement this\ncategory in a single class ``Cs.A``, and set up methods\n``extra_super_categories`` or ``A_extra_super_categories`` methods as\nappropriate. Each such method should return something like\n``[C2s()]`` and not ``[C2s().A()]`` for the latter would likely lead\nto an infinite recursion.\n\n.. TOPIC:: Design discussion\n\n    Supporting similar deduction rules will be an important feature in\n    the future, with quite a few occurences already implemented in\n    upcoming tickets. For the time being though there is a single\n    occurrence of this idiom outside of the tests. So this would be an\n    easy thing to refactor after :trac:`10963` if a better idiom is\n    found.\n\nLarger synthetic examples\n~~~~~~~~~~~~~~~~~~~~~~~~~\n\nWe now consider some larger synthetic examples to check that the\nmachinery works as expected. Let us start with a category defining a\nbunch of axioms, using :func:`axiom` for conciseness (don't do it for\nreal axioms; they deserve a full documentation!)::\n\n    sage: from sage.categories.category_singleton import Category_singleton\n    sage: from sage.categories.category_with_axiom import axiom\n    sage: import sage.categories.category_with_axiom\n    sage: all_axioms = sage.categories.category_with_axiom.all_axioms\n    sage: all_axioms += (\"B\",\"C\",\"D\",\"E\",\"F\")\n\n    sage: class As(Category_singleton):\n    ....:     def super_categories(self):\n    ....:         return [Objects()]\n    ....:\n    ....:     class SubcategoryMethods:\n    ....:         B = axiom(\"B\")\n    ....:         C = axiom(\"C\")\n    ....:         D = axiom(\"D\")\n    ....:         E = axiom(\"E\")\n    ....:         F = axiom(\"F\")\n    ....:\n    ....:     class B(CategoryWithAxiom):\n    ....:         pass\n    ....:     class C(CategoryWithAxiom):\n    ....:         pass\n    ....:     class D(CategoryWithAxiom):\n    ....:         pass\n    ....:     class E(CategoryWithAxiom):\n    ....:         pass\n    ....:     class F(CategoryWithAxiom):\n    ....:         pass\n\nNow we construct a subcategory where, by some theorem of William,\naxioms ``B`` and ``C`` together are equivalent to ``E`` and ``F``\ntogether::\n\n    sage: class A1s(Category_singleton):\n    ....:     def super_categories(self):\n    ....:         return [As()]\n    ....:\n    ....:     class B(CategoryWithAxiom):\n    ....:         def C_extra_super_categories(self):\n    ....:             return [As().E(), As().F()]\n    ....:\n    ....:     class E(CategoryWithAxiom):\n    ....:         def F_extra_super_categories(self):\n    ....:             return [As().B(), As().C()]\n\n    sage: A1s().B().C()\n    Category of e f a1s\n\nThe axioms ``B`` and ``C`` do not show up in the name of the obtained\ncategory because, for concision, the printing uses some heuristics to\nnot show axioms that are implied by others. But they are satisfied::\n\n    sage: sorted(A1s().B().C().axioms())\n    ['B', 'C', 'E', 'F']\n\nNote also that this is a join category::\n\n    sage: type(A1s().B().C())\n    <class 'sage.categories.category.JoinCategory_with_category'>\n    sage: A1s().B().C().super_categories()\n    [Category of e a1s,\n     Category of f as,\n     Category of b a1s,\n     Category of c as]\n\nAs desired, William's theorem holds::\n\n    sage: A1s().B().C() is A1s().E().F()\n    True\n\nand propagates appropriately to subcategories::\n\n    sage: C =  A1s().E().F().D().B().C()\n    sage: C is A1s().B().C().E().F().D()  # commutativity\n    True\n    sage: C is A1s().E().F().E().F().D()  # William's theorem\n    True\n    sage: C is A1s().E().E().F().F().D()  # commutativity\n    True\n    sage: C is A1s().E().F().D()          # idempotency\n    True\n    sage: C is A1s().D().E().F()\n    True\n\nIn this quick variant, we actually implement the category of ``b c\na2s``, and choose to do so in ``A2s.B.C``::\n\n    sage: class A2s(Category_singleton):\n    ....:     def super_categories(self):\n    ....:         return [As()]\n    ....:\n    ....:     class B(CategoryWithAxiom):\n    ....:         class C(CategoryWithAxiom):\n    ....:             def extra_super_categories(self):\n    ....:                 return [As().E(), As().F()]\n    ....:\n    ....:     class E(CategoryWithAxiom):\n    ....:         def F_extra_super_categories(self):\n    ....:             return [As().B(), As().C()]\n\n\n    sage: A2s().B().C()\n    Category of e f a2s\n    sage: sorted(A2s().B().C().axioms())\n    ['B', 'C', 'E', 'F']\n    sage: type(A2s().B().C())\n    <class '__main__.A2s.B.C_with_category'>\n\nAs desired, William's theorem and its consequences hold::\n\n    sage: A2s().B().C() is A2s().E().F()\n    True\n    sage: C =  A2s().E().F().D().B().C()\n    sage: C is A2s().B().C().E().F().D()  # commutativity\n    True\n    sage: C is A2s().E().F().E().F().D()  # William's theorem\n    True\n    sage: C is A2s().E().E().F().F().D()  # commutativity\n    True\n    sage: C is A2s().E().F().D()          # idempotency\n    True\n    sage: C is A2s().D().E().F()\n    True\n\nFinally, we \"accidentally\" implement the category of ``b c a1s``, both\nin ``A3s.B.C`` and ``A3s.E.F``::\n\n    sage: class A3s(Category_singleton):\n    ....:     def super_categories(self):\n    ....:         return [As()]\n    ....:\n    ....:     class B(CategoryWithAxiom):\n    ....:         class C(CategoryWithAxiom):\n    ....:             def extra_super_categories(self):\n    ....:                 return [As().E(), As().F()]\n    ....:\n    ....:     class E(CategoryWithAxiom):\n    ....:         class F(CategoryWithAxiom):\n    ....:             def extra_super_categories(self):\n    ....:                 return [As().B(), As().C()]\n\nWe can still construct, say::\n\n    sage: A3s().B()\n    Category of b a3s\n    sage: A3s().C()\n    Category of c a3s\n\nHowever,\n::\n\n    sage: A3s().B().C()           # not tested\n\nruns into an infinite recursion loop, as ``A3s().B().C()`` wants to\nhave ``A3s().E().F()`` as super category and reciprocally.\n\n.. TODO::\n\n    The above example violates the specifications (a category should\n    be modelled by at most one class), so it's appropriate that it\n    fails. Yet, the error message could be usefully complemented by\n    some hint at what the source of the problem is (a category\n    implemented in two distinct classes). Leaving a large enough piece\n    of the backtrace would be useful though, so that one can explore\n    where the issue comes from (e.g. with post mortem debugging).\n\nSpecifications\n==============\n\nAfter fixing some vocabulary, we summarize here some specifications\nabout categories and axioms.\n\nThe lattice of constructible categories\n---------------------------------------\n\nA mathematical category `C` is *implemented* if there is a class in\nSage modelling it; it is *constructible* if it is either implemented,\nor is the intersection of *implemented* categories; in the latter case\nit is modelled by a :class:`~.category.JoinCategory`. The comparison of two\nconstructible categories with the :meth:`Category.is_subcategory`\nmethod is supposed to model the comparison of the corresponding\nmathematical categories for inclusion of the objects (see\n:ref:`category-primer-subcategory` for details). For example::\n\n    sage: Fields().is_subcategory(Rings())\n    True\n\nHowever this modelling may be incomplete. It can happen that a\nmathematical fact implying that a category `A` is a subcategory of a\ncategory `B` is not implemented. Still, the comparison should endow\nthe set of constructible categories with a poset structure and in fact\na lattice structure.\n\nIn this lattice, the join of two categories (:meth:`Category.join`) is\nsupposed to model their intersection. Given that we compare categories\nfor inclusion, it would be more natural to call this operation the\n*meet*; blames go to me (Nicolas) for originally comparing categories\nby *amount of structure* rather than by *inclusion*. In practice, the\njoin of two categories may be a strict super category of their\nintersection; first because this intersection might not be\nconstructible; second because Sage might miss some mathematical\ninformation to recover the smallest constructible super category of\nthe intersection.\n\nAxioms\n------\n\nWe say that an axiom ``A`` is *defined by* a category ``Cs()`` if\n``Cs`` defines an appropriate method ``Cs.SubcategoryMethods.A``, with\nthe semantic of the axiom specified in the documentation; for any\nsubcategory ``Ds()``, ``Ds().A()`` models the subcategory of the\nobjects of ``Ds()`` satisfying ``A``. In this case, we say that the\naxiom ``A`` is *defined for* the category ``Ds()``. Furthermore,\n``Ds`` *implements the axiom* ``A`` if ``Ds`` has a category with\naxiom as nested class ``Ds.A``. The category ``Ds()`` *satisfies* the\naxiom if ``Ds()`` is a subcategory of ``Cs().A()`` (meaning that all\nthe objects of ``Ds()`` are known to satisfy the axiom ``A``).\n\nA digression on the structure of fibers when adding an axiom\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nConsider the application `\\phi_A` which maps a category to its\ncategory of objects satisfying `A`. Equivalently, `\\phi_A` is\ncomputing the intersection with the defining category with axiom of\n`A`. It follows immediately from the latter that `\\phi_A` is a\nregressive endomorphism of the lattice of categories. It restricts\nto a regressive endomorphism ``Cs() |-> Cs().A()``\non the lattice of constructible categories.\n\nThis endomorphism may have non trivial fibers, as in our favorite\nexample: ``DivisionRings()`` and ``Fields()`` are in the same fiber\nfor the axiom ``Finite``::\n\n    sage: DivisionRings().Finite() is Fields().Finite()\n    True\n\nConsider the intersection `S` of such a fiber of `\\phi_A` with the\nupper set `I_A` of categories that do not satisfy ``A``. The fiber\nitself is a sublattice. However `I_A` is not guaranteed to be stable\nunder intersection (though exceptions should be rare). Therefore,\nthere is a priori no guarantee that `S` would be stable under\nintersection. Also it's presumably finite, in fact small, but this is\nnot guaranteed either.\n\nSpecifications\n--------------\n\n- Any constructible category ``C`` should admit a finite number of\n  larger constructible categories.\n\n- The methods ``super_categories``, ``extra_super_categories``, and\n  friends should always return strict supercategories.\n\n  For example, to specify that a finite division ring is a finite\n  field, ``DivisionRings.Finite_extra_super_categories`` should not\n  return ``Fields().Finite()``! It could possibly return ``Fields()``;\n  but it's preferable to return the largest category that contains the\n  relevant information, in this case ``Magmas().Commutative()``, and\n  to let the infrastructure apply the derivations.\n\n- The base category of a :class:`CategoryWithAxiom` should be an\n  implemented category (i.e. not a\n  :class:`~.category.JoinCategory`). This is checked by\n  :meth:`CategoryWithAxiom._test_category_with_axiom`.\n\n- Arborescent structure: Let ``Cs()`` be a category, and `S` be some\n  set of axioms defined in some super categories of ``Cs()`` but not\n  satisfied by ``Cs()``. Suppose we want to provide a category with\n  axiom for the elements of ``Cs()`` satisfying the axioms in\n  `S`. Then, there should be a single enumeration ``A1, A2, ..., Ak``\n  without repetition of axioms in `S` such that\n  ``Cs.A1.A2....Ak`` is an implemented category.\n  Furthermore, every intermediate step\n  ``Cs.A1.A2....Ai`` with `i\\leq k` should be a category with axiom\n  having ``Ai`` as axiom and ``Cs.A1.A2....Ai-1`` as base category\n  class; this base category class should not satisfy ``Ai``. In\n  particular, when some axioms of `S` can be deduced from previous\n  ones by deduction rules, they should not appear in the enumeration\n  ``A1, A2, ..., Ak``.\n\n- In particular, if ``Cs()`` is a category that satisfies some axiom\n  ``A`` (e.g. from one of its super categories), then it should not\n  implement that axiom. For example, a category class ``Cs`` can never\n  have a nested class ``Cs.A.A``. Similarly, applying the\n  specification recursively, a category satisfying ``A`` cannot have a\n  nested class ``Cs.A1.A2.A3.A`` where ``A1``, ``A2``, ``A3`` are\n  axioms.\n\n- A category can only implement an axiom if this axiom is defined by\n  some super category. The code has not been systematically checked to\n  support having two super categories defining the same axiom (which\n  should of course have the same semantic). You are welcome to try, at\n  your own risk. :-)\n\n- When a category defines an axiom or functorial construction ``A``,\n  this fixes the semantic of ``A`` for all the subcategories. In\n  particular, if two categories define ``A``, then these categories\n  should be independent, and either the semantic of ``A`` should be\n  the same, or there should be no natural intersection between the two\n  hierarchies of subcategories.\n\n- Any super category of a\n  :class:`~.category.CategoryWithParameters` should either be a\n  :class:`~.category.CategoryWithParameters` or a\n  :class:`Category_singleton`.\n\n- A :class:`CategoryWithAxiom` having a\n  :class:`~sage.categories.category_singleton.Category_singleton` as base\n  category should be a :class:`CategoryWithAxiom_singleton`. This is handled\n  automatically by :meth:`CategoryWithAxiom.__init__` and checked in\n  :meth:`CategoryWithAxiom._test_category_with_axiom`.\n\n- A :class:`CategoryWithAxiom` having a\n  :class:`Category_over_base_ring` as base category should be a\n  :class:`Category_over_base_ring`. This currently has to be handled\n  by hand, using :class:`CategoryWithAxiom_over_base_ring`. This is\n  checked in :meth:`CategoryWithAxiom._test_category_with_axiom`.\n\n.. TODO::\n\n    The following specifications would be desirable but are not yet\n    implemented:\n\n    - A functorial construction category (Graded, CartesianProducts,\n      ...) having a :class:`Category_singleton` as base category\n      should be a :class:`CategoryWithAxiom_singleton`.\n\n      Nothing difficult to implement, but this will need to rework the\n      current \"no subclass of a concrete class\" assertion test of\n      :meth:`Category_singleton.__classcall__`.\n\n    - Similarly, a covariant functorial construction category having a\n      :class:`Category_over_base_ring` as base category should be a\n      :class:`Category_over_base_ring`.\n\n    The following specification might be desirable, or not:\n\n    - A join category involving a :class:`Category_over_base_ring`\n      should be a :class:`Category_over_base_ring`. In the mean\n      time, a ``base_ring`` method is automatically provided for most\n      of those by :meth:`Modules.SubcategoryMethods.base_ring`.\n\n\nDesign goals\n============\n\nAs pointed out in the primer, the main design goal of the axioms\ninfrastructure is to subdue the potential combinatorial explosion of\nthe category hierarchy by letting the developer focus on implementing\na few bookshelves for which there is actual code or mathematical\ninformation, and let Sage *compose dynamically and lazily* these\nbuilding blocks to construct the minimal hierarchy of classes needed\nfor the computation at hand. This allows for the infrastructure to\nscale smoothly as bookshelves are added, extended, or reorganized.\n\nOther design goals include:\n\n - Flexibility in the code layout: the category of, say, finite sets\n   can be implemented either within the Sets category (in a nested\n   class ``Sets.Finite``), or in a separate file (typically in a class\n   ``FiniteSets`` in a lazily imported module\n   sage.categories.finite_sets).\n\n - Single point of truth: a theorem, like Wedderburn's, should be\n   implemented in a single spot.\n\n - Single entry point: for example, from the entry :class:`Rings`, one\n   can explore a whole range of related categories just by applying\n   axioms and constructions::\n\n       sage: Rings().Commutative().Finite().NoZeroDivisors()\n       Category of finite integral domains\n       sage: Rings().Finite().Division()\n       Category of finite fields\n\n   This will allow for progressively getting rid of all the entries\n   like :class:`GradedHopfAlgebrasWithBasis` which are polluting the\n   global name space.\n\n   Note that this is not about precluding the existence of multiple\n   natural ways to construct the same category::\n\n       sage: Groups().Finite()\n       Category of finite groups\n       sage: Monoids().Finite().Inverse()\n       Category of finite groups\n       sage: Sets().Finite() & Monoids().Inverse()\n       Category of finite groups\n\n - Concise idioms for the users (adding axioms, ...)\n\n - Concise idioms and well highlighted hierarchy of bookshelves for\n   the developer (especially with code folding)\n\n - Introspection friendly (listing the axioms, recovering the mixins)\n\n.. NOTE::\n\n    The constructor for instances of this class takes as input the\n    base category. Hence, they should in principle be constructed\n    as::\n\n        sage: FiniteSets(Sets())\n        Category of finite sets\n\n        sage: Sets.Finite(Sets())\n        Category of finite sets\n\n    None of these idioms are really practical for the user. So instead,\n    this object is to be constructed using any of the following idioms::\n\n        sage: Sets()._with_axiom('Finite')\n        Category of finite sets\n        sage: FiniteSets()\n        Category of finite sets\n        sage: Sets().Finite()\n        Category of finite sets\n\n    The later two are implemented using respectively\n    :meth:`CategoryWithAxiom.__classcall__` and\n    :meth:`CategoryWithAxiom.__classget__`.\n\nUpcoming features\n=================\n\n.. TODO:\n\n    - Implement compatibility axiom / functorial constructions. For\n      example, one would want to have::\n\n          A.CartesianProducts() & B.CartesianProducts() = (A&B).CartesianProducts()\n\n    - Once full subcategories are implemented (see :trac:`10668`),\n      make the relevant categories with axioms be such. This can be\n      done systematically for, e.g., the axioms ``Associative`` or\n      ``Commutative``, but not for the axiom ``Unital``: a semigroup\n      morphism between two monoids need not preserve the unit.\n\n      Should all full subcategories be implemented in term of axioms?\n\n.. _axioms-algorithmic:\n\nAlgorithms\n==========\n\nComputing joins\n---------------\n\nThe workhorse of the axiom infrastructure is the algorithm for\ncomputing the join `J` of a set `C_1, \\ldots, C_k` of categories (see\n:meth:`Category.join`). Formally, `J` is defined as the largest\nconstructible category such that `J \\subset C_i` for all `i`, and\n`J \\subset C.A()` for every constructible category `C \\supset J`\nand any axiom `A` satisfied by `J`.\n\nThe join `J` is naturally computed as a closure in the lattice of\nconstructible categories: it starts with the `C_i`'s, gathers the set\n`S` of all the axioms satisfied by them, and repeteadly adds each\naxiom `A` to those categories that do not yet satisfy `A` using\n:meth:`Category._with_axiom`. Due to deduction rules or (extra) super\ncategories, new categories or new axioms may appear in the\nprocess. The process stops when each remaining category has been\ncombined with each axiom. In practice, only the smallest categories\nare kept along the way; this is correct because adding an axiom is\ncovariant: ``C.A()`` is a subcategory of ``D.A()`` whenever ``C`` is a\nsubcategory of ``D``.\n\nAs usual in such closure computations, the result does not depend on\nthe order of execution. Futhermore, given that adding an axiom is an\nidempotent and regressive operation, the process is guaranteed to stop\nin a number of steps which is bounded by the number of super\ncategories of `J`. In particular, it is a finite process.\n\n.. TODO::\n\n    Detail this a bit. What could typically go wrong is a situation\n    where, for some category ``C1``, ``C1.A()`` specifies a category\n    ``C2`` as super category such that ``C2.A()`` specifies ``C3`` as\n    super category such that ...; this would clearly cause an infinite\n    execution. Note that this situation violates the specifications\n    since ``C1.A()`` is supposed to be a subcategory of ``C2.A()``,\n    ... so we would have an infinite increasing chain of constructible\n    categories.\n\n    It's reasonnable to assume that there is a finite number of axioms\n    defined in the code. There remains to use this assumption to argue\n    that any infinite execution of the algorithm would give rise to\n    such an infinite sequence.\n\nAdding an axiom\n---------------\n\nLet ``Cs`` be a category and ``A`` an axiom defined for this\ncategory. To compute ``Cs().A()``, there are two cases.\n\nAdding an axiom ``A`` to a category ``Cs()`` not implementing it\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nIn this case, ``Cs().A()`` returns the join of:\n\n- ``Cs()``\n- ``Bs().A()`` for every direct super category ``Bs()`` of ``Cs()``\n- the categories appearing in ``Cs().A_extra_super_categories()``\n\nThis is a highly recursive process. In fact, as such, it would run\nright away into an infinite loop! Indeed, the join of ``Cs()`` with\n``Bs().A()`` would trigger the construction of ``Cs().A()`` and\nreciprocally. To avoid this, the :meth:`Category.join` method itself\ndoes not use :meth:`Category._with_axiom` to add axioms, but its\nsister :meth:`Category._with_axiom_as_tuple`; the latter builds a\ntuple of categories that should be joined together but leaves the\ncomputation of the join to its caller, the master join calculation.\n\nAdding an axiom ``A`` to a category ``Cs()`` implementing it\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nIn this case ``Cs().A()`` simply constructs an instance `D` of\n``Cs.A`` which models the desired category. The non trivial part is\nthe construction of the super categories of `D`. Very much like\nabove, this includes:\n\n- ``Cs()``\n- ``Bs().A()`` for every super category ``Bs()`` of ``Cs()``\n- the categories appearing in ``D.extra_super_categories()``\n\nThis by itself may not be sufficient, due in particular to deduction\nrules. On may for example discover a new axiom ``A1`` satisfied by\n`D`, imposing to add ``A1`` to all of the above categories. Therefore\nthe super categories are computed as the join of the above categories.\nUp to one twist: as is, the computation of this join would trigger\nrecursively a recalculation of ``Cs().A()``! To avoid this,\n:meth:`Category.join` is given an optional argument to specify that\nthe axiom ``A`` should *not* be applied to ``Cs()``.\n\nSketch of proof of correctness and evaluation of complexity\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nAs we have seen, this is a highly recursive process! In particular,\none needs to argue that, as long as the specifications are satisfied,\nthe algorithm won't run in an infinite recursion, in particular in\ncase of deduction rule.\n\n.. TOPIC:: Theorem\n\n    Consider the construction of a category `C` by adding an axiom to\n    a category (or computing of a join). Let `H` be the hierarchy of\n    implemented categories above `C`. Let `n` and `m` be respectively\n    the number of categories and the number of inheritance edges in\n    `H`.\n\n    Assuming that the specifications are satisfied, the construction\n    of `C` involves constructing the categories in `H` exactly once\n    (and no other category), and at most `n` join calculations. In\n    particular, the time complexity should be, roughly speaking,\n    bounded by `n^2`. In particular, it's finite.\n\n.. TOPIC:: Remark\n\n    It's actually to be expected that the complexity is more of the\n    order of magnitude of `na+m`, where `a` is the number of axioms\n    satisfied by `C`. But this is to be checked in detail, in\n    particular due to the many category inclusion tests involved.\n\nThe key argument is that :class:`Category.join` cannot call itself\nrecursively without going through the construction of some implemented\ncategory. In turn, the construction of some implemented category `C`\nonly involves constructing strictly smaller categories, and possibly a\ndirect join calculation whose result is strictly smaller than\n`C`. This statement is obvious if `C` implements the\n``super_categories`` method directly, and easy to check for functorial\nconstruction categories. It requires a proof for categories with\naxioms since there is a recursive join involved.\n\n.. TOPIC:: Lemma\n\n    Let `C` be a category implementing an axiom `A`. Recall that the\n    construction of ``C.A()`` involves a single direct join\n    calculation for computing the super categories. No other direct\n    join calculation occur, and the calculation involves only\n    implemented categories that are strictly smaller than ``C.A()``.\n\n.. TOPIC:: Proof\n\n   Let `D` be a category involved in the join calculation for the\n   super categories of ``C.A()``, and assume by induction that `D` is\n   strictly smaller than ``C.A()``. A category `E` newly constructed\n   from `D` can come from:\n\n   - ``D.(extra_)super_categories()``\n\n     In this case, the specifications impose that `E` should be\n     strictly smaller than `D` and therefore strictly smaller than\n     `C`.\n\n   - ``D.with_axiom_as_tuple('B')`` or ``D.B_extra_super_categories()``\n     for some axiom `B`\n\n     In this case, the axiom `B` is satisfied by some subcategory of\n     ``C.A()``, and therefore must be satisfied by ``C.A()`` itself.\n     Since adding an axiom is a regressive construction, `E` must be a\n     subcategory of ``C.A()``. If there is equality, then `E` and\n     ``C.A()`` must have the same class, and therefore, `E` must be\n     directly constructed as ``C.A()``. However the join construction\n     explicitly prevents this call.\n\n   Note that a call to ``D.with_axiom_as_tuple('B')`` does not trigger\n   a direct join calculation; but of course, if `D` implements `B`,\n   the construction of the implemented category ``E = D.B()`` will\n   involve a strictly smaller join calculation.\n\n\nConclusion\n==========\n\nThis is the end of the axioms documentation. Congratulations on\nhaving read that far!\n\n\nTests\n=====\n\n.. NOTE::\n\n    Quite a few categories with axioms are constructed early on during\n    Sage's startup. Therefore, when playing around with the\n    implementation of the axiom infrastructure, it is easy to break\n    Sage. The following sequence of tests is designed to test the\n    infrastructure from the ground up even in a partially broken\n    Sage. Please don't remove the imports!\n\nTESTS:\n\n::\n\n    sage: Magmas()\n    Category of magmas\n    sage: Magmas().Finite()\n    Category of finite magmas\n\n    sage: Magmas().Unital()\n    Category of unital magmas\n    sage: Magmas().Commutative().Unital()\n    Category of commutative unital magmas\n    sage: Magmas().Associative()\n    Category of semigroups\n    sage: Magmas().Associative() & Magmas().Unital().Inverse() & Sets().Finite()\n    Category of finite groups\n    sage: _ is Groups().Finite()\n    True\n\n    sage: from sage.categories.semigroups import Semigroups\n    sage: Semigroups()\n    Category of semigroups\n    sage: Semigroups().Finite()\n    Category of finite semigroups\n\n    sage: from sage.categories.modules_with_basis import ModulesWithBasis\n    sage: ModulesWithBasis(QQ) is Modules(QQ).WithBasis()\n    True\n    sage: ModulesWithBasis(ZZ) is Modules(ZZ).WithBasis()\n    True\n\n    sage: Semigroups().Unital()\n    Category of monoids\n    sage: Semigroups().Unital().Commutative()\n    Category of commutative monoids\n    sage: Semigroups().Commutative()\n    Category of commutative semigroups\n    sage: Semigroups().Commutative().Unital()\n    Category of commutative monoids\n    sage: Semigroups().Commutative().Unital().super_categories()\n    [Category of monoids, Category of commutative magmas]\n\n    sage: AdditiveMagmas().AdditiveAssociative().AdditiveCommutative()\n    Category of commutative additive semigroups\n\n    sage: from sage.categories.magmas_and_additive_magmas import MagmasAndAdditiveMagmas\n    sage: C = CommutativeAdditiveMonoids() & Monoids() & MagmasAndAdditiveMagmas().Distributive(); C\n    Category of semirings\n    sage: C is (CommutativeAdditiveMonoids() & Monoids()).Distributive()\n    True\n    sage: C.AdditiveInverse()\n    Category of rings\n    sage: Rings().axioms()\n    frozenset({'AdditiveAssociative',\n               'AdditiveCommutative',\n               'AdditiveInverse',\n               'AdditiveUnital',\n               'Associative',\n               'Distributive',\n               'Unital'})\n    sage: sorted(Rings().axioms())\n    ['AdditiveAssociative', 'AdditiveCommutative', 'AdditiveInverse',\n     'AdditiveUnital', 'Associative', 'Distributive', 'Unital']\n\n    sage: Domains().Commutative()\n    Category of integral domains\n\n    sage: DivisionRings().Finite() # Wedderburn's theorem\n    Category of finite fields\n\n    sage: FiniteMonoids().Algebras(QQ)\n    Join of Category of monoid algebras over Rational Field\n        and Category of finite dimensional algebras with basis over Rational Field\n        and Category of finite set algebras over Rational Field\n    sage: FiniteGroups().Algebras(QQ)\n    Category of finite group algebras over Rational Field\n\"\"\"\n#*****************************************************************************\n#  Copyright (C) 2011-2014 Nicolas M. Thiery <nthiery at users.sf.net>\n#\n#  Distributed under the terms of the GNU General Public License (GPL)\n#                  http://www.gnu.org/licenses/\n#*****************************************************************************\nfrom __future__ import print_function\n\nimport importlib\nimport re\nfrom sage.misc.cachefunc import cached_method, cached_function\nfrom sage.misc.lazy_attribute import lazy_class_attribute\nfrom sage.misc.lazy_import import LazyImport\nfrom sage.misc.misc import call_method\nfrom sage.categories.category import Category\nfrom sage.categories.category_singleton import Category_singleton\nfrom sage.categories.category_types import Category_over_base_ring\nfrom sage.structure.dynamic_class import DynamicMetaclass\nfrom sage.categories.category_cy_helper import AxiomContainer, canonicalize_axioms, _sort_uniq\n\n# The order of the axioms in this lists implies that\n# Magmas().Commutative().Unital() is printed as\n# ``Category of commutative unital magmas''\n\nall_axioms = AxiomContainer()\nall_axioms += (\"Flying\", \"Blue\",\n               \"Compact\",\n               \"Differentiable\", \"Smooth\", \"Analytic\", \"AlmostComplex\",\n               \"FinitelyGeneratedAsMagma\",\n               \"WellGenerated\",\n               \"Facade\", \"Finite\", \"Infinite\",\n               \"Complete\",\n               \"FiniteDimensional\", \"Connected\", \"WithBasis\",\n               \"Irreducible\",\n               \"Commutative\", \"Associative\", \"Inverse\", \"Unital\", \"Division\", \"NoZeroDivisors\",\n               \"AdditiveCommutative\", \"AdditiveAssociative\", \"AdditiveInverse\", \"AdditiveUnital\",\n               \"Distributive\",\n               \"Endset\",\n              )\n\ndef uncamelcase(s,separator=\" \"):\n    \"\"\"\n    EXAMPLES::\n\n        sage: sage.categories.category_with_axiom.uncamelcase(\"FiniteDimensionalAlgebras\")\n        'finite dimensional algebras'\n        sage: sage.categories.category_with_axiom.uncamelcase(\"JTrivialMonoids\")\n        'j trivial monoids'\n        sage: sage.categories.category_with_axiom.uncamelcase(\"FiniteDimensionalAlgebras\", \"_\")\n        'finite_dimensional_algebras'\n    \"\"\"\n    return re.sub(\"(?!^)[A-Z]\", lambda match: separator+match.group()[0], s).lower()\n\ndef base_category_class_and_axiom(cls):\n    \"\"\"\n    Try to deduce the base category and the axiom from the name of ``cls``.\n\n    The heuristic is to try to decompose the name as the concatenation\n    of the name of a category and the name of an axiom, and looking up\n    that category in the standard location (i.e. in\n    :mod:`sage.categories.hopf_algebras` for :class:`HopfAlgebras`,\n    and in :mod:`sage.categories.sets_cat` as a special case\n    for :class:`Sets`).\n\n    If the heuristic succeeds, the result is guaranteed to be\n    correct. Otherwise, an error is raised.\n\n    EXAMPLES::\n\n        sage: from sage.categories.category_with_axiom import base_category_class_and_axiom, CategoryWithAxiom\n        sage: base_category_class_and_axiom(FiniteSets)\n        (<class 'sage.categories.sets_cat.Sets'>, 'Finite')\n        sage: Sets.Finite\n        <class 'sage.categories.finite_sets.FiniteSets'>\n        sage: base_category_class_and_axiom(Sets.Finite)\n        (<class 'sage.categories.sets_cat.Sets'>, 'Finite')\n\n        sage: base_category_class_and_axiom(FiniteDimensionalHopfAlgebrasWithBasis)\n        (<class 'sage.categories.hopf_algebras_with_basis.HopfAlgebrasWithBasis'>, 'FiniteDimensional')\n\n        sage: base_category_class_and_axiom(HopfAlgebrasWithBasis)\n        (<class 'sage.categories.hopf_algebras.HopfAlgebras'>, 'WithBasis')\n\n    Along the way, this does some sanity checks::\n\n        sage: class FacadeSemigroups(CategoryWithAxiom):\n        ....:     pass\n        sage: base_category_class_and_axiom(FacadeSemigroups)\n        Traceback (most recent call last):\n        ...\n        AssertionError: Missing (lazy import) link for <class 'sage.categories.semigroups.Semigroups'> to <class '__main__.FacadeSemigroups'> for axiom Facade?\n\n        sage: Semigroups.Facade = FacadeSemigroups\n        sage: base_category_class_and_axiom(FacadeSemigroups)\n        (<class 'sage.categories.semigroups.Semigroups'>, 'Facade')\n\n    .. NOTE::\n\n        In the following example, we could possibly retrieve ``Sets``\n        from the class name. However this cannot be implemented\n        robustly until :trac:`9107` is fixed. Anyway this feature\n        has not been needed so far::\n\n            sage: Sets.Infinite\n            <class 'sage.categories.sets_cat.Sets.Infinite'>\n            sage: base_category_class_and_axiom(Sets.Infinite)\n            Traceback (most recent call last):\n            ...\n            TypeError: Could not retrieve the base category class and axiom for <class 'sage.categories.sets_cat.Sets.Infinite'>.\n            ...\n    \"\"\"\n    if \".\" in cls.__name__:\n        # Case 1: class name of the form Sets.Infinite\n        # Start of implementation when #9107 will be fixed:\n        # axiom = cls.__name__.split(\".\")[-1]\n        # ...\n        pass\n    else:\n        # Case 2: class name of the form FiniteSets or AlgebrasWithBasis,\n        # with the base class (say Algebras) being implemented in the\n        # standard location (sage.categories.algebras)\n        name = cls.__name__\n        for axiom in all_axioms:\n            if axiom == \"WithBasis\" and name.endswith(axiom):\n                base_name = name[:-len(axiom)]\n            elif name.startswith(axiom):\n                base_name = name[len(axiom):]\n            else:\n                continue\n            if base_name == \"Sets\": # Special case for Sets which is in sets_cat\n                base_module_name = \"sets_cat\"\n            else:\n                base_module_name = uncamelcase(base_name, \"_\")\n            try:\n                base_module = importlib.import_module(\"sage.categories.\"+base_module_name)\n                base_category_class = getattr(base_module, base_name)\n                assert getattr(base_category_class, axiom, None) is cls, \\\n                    \"Missing (lazy import) link for {} to {} for axiom {}?\".format(base_category_class, cls, axiom)\n                return base_category_class, axiom\n            except (ImportError,AttributeError):\n                pass\n    raise TypeError(\"\"\"Could not retrieve the base category class and axiom for {}.\nPlease specify it explictly using the attribute _base_category_class_and_axiom.\nSee CategoryWithAxiom for details.\"\"\".format(cls))\n\n@cached_function\ndef axiom_of_nested_class(cls, nested_cls):\n    r\"\"\"\n    Given a class and a nested axiom class, return the axiom.\n\n    EXAMPLES:\n\n    This uses some heuristics like checking if the nested_cls carries\n    the name of the axiom, or is built by appending or prepending the\n    name of the axiom to that of the class::\n\n        sage: from sage.categories.category_with_axiom import TestObjects, axiom_of_nested_class\n        sage: axiom_of_nested_class(TestObjects, TestObjects.FiniteDimensional)\n        'FiniteDimensional'\n        sage: axiom_of_nested_class(TestObjects.FiniteDimensional, TestObjects.FiniteDimensional.Finite)\n        'Finite'\n        sage: axiom_of_nested_class(Sets, FiniteSets)\n        'Finite'\n        sage: axiom_of_nested_class(Algebras, AlgebrasWithBasis)\n        'WithBasis'\n\n    In all other cases, the nested class should provide an attribute\n    ``_base_category_class_and_axiom``::\n\n        sage: Semigroups._base_category_class_and_axiom\n        (<class 'sage.categories.magmas.Magmas'>, 'Associative')\n        sage: axiom_of_nested_class(Magmas, Semigroups)\n        'Associative'\n    \"\"\"\n    try:\n        axiom = nested_cls.__dict__[\"_base_category_class_and_axiom\"][1]\n    except KeyError:\n        assert not isinstance(cls, DynamicMetaclass)\n        nested_cls_name = nested_cls.__name__.split(\".\")[-1]\n        if nested_cls_name in all_axioms:\n            axiom = nested_cls_name\n        else:\n            cls_name = cls.__name__.split(\".\")[-1]\n            if nested_cls_name.startswith(cls_name):\n                axiom = nested_cls_name[len(cls_name):]\n            elif nested_cls_name.endswith(cls_name):\n                axiom = nested_cls_name[:-len(cls_name)]\n            else:\n                raise ValueError(\"could not infer axiom for the nested class {} of {}\".format(nested_cls, cls))\n    assert axiom in all_axioms, \\\n        \"Incorrect deduction ({}) for the name of the axiom for the nested class {} of {}\".format(axiom, nested_cls, cls)\n    assert axiom in cls.__dict__ and cls.__dict__[axiom] == nested_cls, \\\n        \"{} not a nested axiom class of {} for axiom {}\".format(nested_cls, cls, axiom)\n    return axiom\n\nclass CategoryWithAxiom(Category):\n    r\"\"\"\n    An abstract class for categories obtained by adding an axiom\n    to a base category.\n\n    See the :mod:`category primer <sage.categories.primer>`, and in\n    particular its :ref:`section about axioms <category-primer-axioms>`\n    for an introduction to axioms, and :class:`CategoryWithAxiom` for\n    how to implement axioms and the documentation of the axiom\n    infrastructure.\n\n    .. automethod:: __classcall__\n    .. automethod:: __classget__\n    .. automethod:: __init__\n    .. automethod:: _repr_object_names\n    .. automethod:: _repr_object_names_static\n    .. automethod:: _test_category_with_axiom\n    .. automethod:: _without_axioms\n    \"\"\"\n\n    @lazy_class_attribute\n    def _base_category_class_and_axiom(cls):\n        r\"\"\"\n        The class of the base category and the axiom for this class.\n\n        By default, and when possible, this attribute is deduced from\n        the name of this class (see\n        :func:`base_category_class_and_axiom`). For a nested class,\n        when the category is first created from its base category as\n        in e.g. ``Sets().Infinite()``, this attribute is instead set\n        explicitly by :meth:`__classget__`.\n\n        When this is not sufficient, that is when ``cls`` is not\n        implemented as a nested class and the base category and the\n        axiom cannot be deduced from the name of ``cls``, this\n        attribute should be set explicitly by ``cls``.\n\n        The origin of the attribute is stored in the attribute\n        ``_base_category_class_and_axiom_origin``.\n\n        .. SEEALSO:: :meth:`_axiom`\n\n        EXAMPLES:\n\n        ``CommutativeRings`` is not a nested class, but the name of\n        the base category and the axiom can be deduced::\n\n            sage: CommutativeRings()._base_category_class_and_axiom\n            (<class 'sage.categories.rings.Rings'>, 'Commutative')\n            sage: CommutativeRings()._base_category_class_and_axiom_origin\n            'deduced by base_category_class_and_axiom'\n\n        ``Sets.Infinite`` is a nested class, so the attribute is set\n        by :meth:`CategoryWithAxiom.__classget__` the first time\n        ``Sets().Infinite()`` is called::\n\n            sage: Sets().Infinite()\n            Category of infinite sets\n            sage: Sets.Infinite._base_category_class_and_axiom\n            (<class 'sage.categories.sets_cat.Sets'>, 'Infinite')\n            sage: Sets.Infinite._base_category_class_and_axiom_origin\n            'set by __classget__'\n\n        ``Fields`` is not a nested class, and the name of the base\n        category and axioms cannot be deduced from the name\n        ``Fields``; so this attributes needs to be set explicitly in\n        the ``Fields`` class::\n\n            sage: Fields()._base_category_class_and_axiom\n            (<class 'sage.categories.division_rings.DivisionRings'>, 'Commutative')\n            sage: Fields()._base_category_class_and_axiom_origin\n            'hardcoded'\n\n        .. NOTE::\n\n            The base category class is often another category with\n            axiom, therefore having a special ``__classget__`` method.\n            Storing the base category class and the axiom in a single\n            tuple attribute -- instead of two separate attributes --\n            has the advantage of not trigerring, for example,\n            ``Semigroups.__classget__`` upon\n            ``Monoids._base_category_class``.\n        \"\"\"\n        base_category_class, axiom = base_category_class_and_axiom(cls)\n        cls._base_category_class_and_axiom_origin = \"deduced by base_category_class_and_axiom\"\n        return (base_category_class, axiom)\n\n    _base_category_class_and_axiom_origin = \"hardcoded\"\n\n    @lazy_class_attribute\n    def _axiom(cls):\n        r\"\"\"\n        The axiom for this category with axiom.\n\n        .. SEEALSO:: :meth:`_base_category_class_and_axiom`\n\n        EXAMPLES::\n\n            sage: FiniteSets._axiom\n            'Finite'\n            sage: Sets.Finite._axiom\n            'Finite'\n            sage: Algebras.Commutative._axiom\n            'Commutative'\n\n        The result can be less obvious::\n\n            sage: Semigroups._axiom\n            'Associative'\n            sage: Rings._axiom\n            'Unital'\n            sage: Fields._axiom\n            'Commutative'\n        \"\"\"\n        return cls._base_category_class_and_axiom[1]\n\n    @staticmethod\n    def __classcall__(cls, *args, **options):\n        \"\"\"\n        Make ``FoosBar(**)`` an alias for ``Foos(**)._with_axiom(\"Bar\")``.\n\n        EXAMPLES::\n\n            sage: FiniteGroups()\n            Category of finite groups\n            sage: ModulesWithBasis(ZZ)\n            Category of modules with basis over Integer Ring\n            sage: AlgebrasWithBasis(QQ)\n            Category of algebras with basis over Rational Field\n\n        This is relevant when e.g. ``Foos(**)`` does some non trivial\n        transformations::\n\n            sage: Modules(QQ) is VectorSpaces(QQ)\n            True\n            sage: type(Modules(QQ))\n            <class 'sage.categories.vector_spaces.VectorSpaces_with_category'>\n\n            sage: ModulesWithBasis(QQ) is VectorSpaces(QQ).WithBasis()\n            True\n            sage: type(ModulesWithBasis(QQ))\n            <class 'sage.categories.vector_spaces.VectorSpaces.WithBasis_with_category'>\n        \"\"\"\n        (base_category_class, axiom) = cls._base_category_class_and_axiom\n        if len(args) == 1 and not options and isinstance(args[0], base_category_class):\n            return super(CategoryWithAxiom, cls).__classcall__(cls, args[0])\n        else:\n            # The \"obvious\" idiom\n            ##   return cls(base_category_class(*args, **options))\n            # fails with ModulesWithBasis(QQ) as follows: The\n            # base_category_class is Modules, but Modules(QQ) is an instance\n            # of VectorSpaces and not of Modules. Hence,\n            # ModulesWithBasis.__classcall__ will not accept this instance as\n            # the first argument. Instead, we apply the axiom to the instance:\n            return base_category_class(*args, **options)._with_axiom(axiom)\n\n    @staticmethod\n    def __classget__(cls, base_category, base_category_class):\n        r\"\"\"\n        Implement the binding behavior for categories with axioms.\n\n        This method implements a binding behavior on category with\n        axioms so that, when a category ``Cs`` implements an axiom\n        ``A`` with a nested class ``Cs.A``, the expression ``Cs().A``\n        evaluates to the method defining the axiom ``A`` and not the\n        nested class. See `those design notes\n        <category-with-axiom-design>`_ for the rationale behind this\n        behavior.\n\n        EXAMPLES::\n\n            sage: Sets().Infinite()\n            Category of infinite sets\n            sage: Sets().Infinite\n            Cached version of <function Infinite at ...>\n            sage: Sets().Infinite.f == Sets.SubcategoryMethods.Infinite.f\n            True\n\n        We check that this also works when the class is implemented in\n        a separate file, and lazy imported::\n\n            sage: Sets().Finite\n            Cached version of <function Finite at ...>\n\n        There is no binding behavior when accessing ``Finite`` or\n        ``Infinite`` from the class of the category instead of the\n        category itself::\n\n            sage: Sets.Finite\n            <class 'sage.categories.finite_sets.FiniteSets'>\n            sage: Sets.Infinite\n            <class 'sage.categories.sets_cat.Sets.Infinite'>\n\n        This method also initializes the attribute\n        ``_base_category_class_and_axiom`` if not already set::\n\n            sage: Sets.Infinite._base_category_class_and_axiom\n            (<class 'sage.categories.sets_cat.Sets'>, 'Infinite')\n            sage: Sets.Infinite._base_category_class_and_axiom_origin\n            'set by __classget__'\n        \"\"\"\n        # TODO: this is super paranoid; see if this can be simplified a bit\n        if base_category is not None:\n            assert base_category.__class__ is base_category_class\n            assert isinstance(base_category_class, DynamicMetaclass)\n        if isinstance(base_category_class, DynamicMetaclass):\n            base_category_class = base_category_class.__base__\n        if \"_base_category_class_and_axiom\" not in cls.__dict__:\n            cls._base_category_class_and_axiom = (base_category_class, axiom_of_nested_class(base_category_class, cls))\n            cls._base_category_class_and_axiom_origin = \"set by __classget__\"\n        else:\n            assert cls._base_category_class_and_axiom[0] is base_category_class, \\\n                \"base category class for {} mismatch; expected {}, got {}\".format(\n                 cls, cls._base_category_class_and_axiom[0], base_category_class)\n\n        # Workaround #15648: if Rings.Finite is a LazyImport object,\n        # this forces the substitution of the object back into Rings\n        # to avoid resolving the lazy import over and over\n        if isinstance(base_category_class.__dict__[cls._axiom], LazyImport):\n            setattr(base_category_class, cls._axiom, cls)\n\n        if base_category is None:\n             return cls\n        # For Rings().Finite, this returns the method\n        # Sets.SubcategoryMethods.Finite, with its first argument bound to Rings()\n        return getattr(super(base_category.__class__.__base__, base_category), cls._axiom)\n\n    def __init__(self, base_category):\n        \"\"\"\n        TESTS::\n\n            sage: C = Sets.Finite(); C\n            Category of finite sets\n            sage: type(C)\n            <class 'sage.categories.finite_sets.FiniteSets_with_category'>\n            sage: type(C).__base__.__base__\n            <class 'sage.categories.category_with_axiom.CategoryWithAxiom_singleton'>\n\n            sage: TestSuite(C).run()\n        \"\"\"\n        # A hack to upgrade axiom categories of singleton categories\n        # to be singleton categories themselves\n        if isinstance(base_category, Category_singleton) and not isinstance(self, CategoryWithAxiom_singleton):\n            cls = self.__class__\n            assert cls.__base__ == CategoryWithAxiom\n            cls.__bases__ = (CategoryWithAxiom_singleton,)+cls.__bases__[1:]\n\n        self._base_category = base_category\n        Category.__init__(self)\n\n    def _test_category_with_axiom(self, **options):\n        r\"\"\"\n        Run generic tests on this category with axioms.\n\n        .. SEEALSO:: :class:`TestSuite`.\n\n        This check that an axiom category of a\n        :class:`Category_singleton` is a singleton category, and\n        similarwise for :class`Category_over_base_ring`.\n\n        EXAMPLES::\n\n            sage: Sets().Finite()._test_category_with_axiom()\n            sage: Modules(ZZ).FiniteDimensional()._test_category_with_axiom()\n        \"\"\"\n        tester = self._tester(**options)\n        base = self.base_category()\n        if isinstance(base, Category_singleton):\n            tester.assertIsInstance(self, CategoryWithAxiom_singleton)\n        if isinstance(base, Category_over_base_ring):\n            tester.assertIsInstance(self, CategoryWithAxiom_over_base_ring)\n\n    def extra_super_categories(self):\n        \"\"\"\n        Return the extra super categories of a category with axiom.\n\n        Default implementation which returns ``[]``.\n\n        EXAMPLES::\n\n            sage: FiniteSets().extra_super_categories()\n            []\n        \"\"\"\n        return []\n\n    @cached_method\n    def super_categories(self):\n        \"\"\"\n        Return a list of the (immediate) super categories of\n        ``self``, as per :meth:`Category.super_categories`.\n\n        This implements the property that if ``As`` is a subcategory\n        of ``Bs``, then the intersection of ``As`` with ``FiniteSets()``\n        is a subcategory of ``As`` and of the intersection of ``Bs``\n        with ``FiniteSets()``.\n\n        EXAMPLES:\n\n        A finite magma is both a magma and a finite set::\n\n            sage: Magmas().Finite().super_categories()\n            [Category of magmas, Category of finite sets]\n\n        Variants::\n\n            sage: Sets().Finite().super_categories()\n            [Category of sets]\n\n            sage: Monoids().Finite().super_categories()\n            [Category of monoids, Category of finite semigroups]\n\n        EXAMPLES:\n\n        TESTS::\n\n            sage: from sage.categories.category_with_axiom import TestObjects\n            sage: C = TestObjects().FiniteDimensional().Unital().Commutative().Finite()\n            sage: sorted(C.super_categories(), key=str)\n            [Category of finite commutative test objects,\n             Category of finite dimensional commutative unital test objects,\n             Category of finite finite dimensional test objects]\n        \"\"\"\n        base_category = self._base_category\n        axiom = self._axiom\n        return Category.join((base_category,) +\n                             tuple(cat\n                                   for category in base_category._super_categories\n                                   for cat in category._with_axiom_as_tuple(axiom)) +\n                             tuple(self.extra_super_categories()),\n                             ignore_axioms = ((base_category, axiom),),\n                             as_list = True)\n\n    def additional_structure(self):\n        r\"\"\"\n        Return the additional structure defined by ``self``.\n\n        OUTPUT: ``None``\n\n        By default, a category with axiom defines no additional\n        structure.\n\n        .. SEEALSO:: :meth:`Category.additional_structure`.\n\n        EXAMPLES:\n\n            sage: Sets().Finite().additional_structure()\n            sage: Monoids().additional_structure()\n\n        TESTS::\n\n            sage: Sets().Finite().additional_structure.__module__\n            'sage.categories.category_with_axiom'\n        \"\"\"\n        return None\n\n    @staticmethod\n    def _repr_object_names_static(category, axioms):\n        r\"\"\"\n        INPUT:\n\n        - ``base_category`` -- a category\n        - ``axioms`` -- a list or iterable of strings\n\n        EXAMPLES::\n\n            sage: from sage.categories.category_with_axiom import CategoryWithAxiom\n            sage: CategoryWithAxiom._repr_object_names_static(Semigroups(), [\"Flying\", \"Blue\"])\n            'flying blue semigroups'\n            sage: CategoryWithAxiom._repr_object_names_static(Algebras(QQ), [\"Flying\", \"WithBasis\", \"Blue\"])\n            'flying blue algebras with basis over Rational Field'\n            sage: CategoryWithAxiom._repr_object_names_static(Algebras(QQ), [\"WithBasis\"])\n            'algebras with basis over Rational Field'\n            sage: CategoryWithAxiom._repr_object_names_static(Sets().Finite().Subquotients(), [\"Finite\"])\n            'subquotients of finite sets'\n            sage: CategoryWithAxiom._repr_object_names_static(Monoids(), [\"Unital\"])\n            'monoids'\n            sage: CategoryWithAxiom._repr_object_names_static(Algebras(QQ['x']['y']), [\"Flying\", \"WithBasis\", \"Blue\"])\n            'flying blue algebras with basis over Univariate Polynomial Ring in y over Univariate Polynomial Ring in x over Rational Field'\n\n        If the axioms is a set or frozen set, then they are first\n        sorted using :func:`canonicalize_axioms`::\n\n            sage: CategoryWithAxiom._repr_object_names_static(Semigroups(), set([\"Finite\", \"Commutative\", \"Facade\"]))\n            'facade finite commutative semigroups'\n\n        .. SEEALSO:: :meth:`_repr_object_names`\n\n        .. NOTE::\n\n            The logic here is shared between :meth:`_repr_object_names`\n            and :meth:`.category.JoinCategory._repr_object_names`\n\n        TESTS::\n\n            sage: from sage.categories.homsets import Homsets\n            sage: CategoryWithAxiom._repr_object_names_static(Homsets(), [\"Endset\"])\n            'endsets'\n            sage: CategoryWithAxiom._repr_object_names_static(PermutationGroups(), [\"FinitelyGeneratedAsMagma\"])\n            'finitely generated permutation groups'\n            sage: CategoryWithAxiom._repr_object_names_static(Rings(), [\"FinitelyGeneratedAsMagma\"])\n            'finitely generated as magma rings'\n        \"\"\"\n        from sage.categories.additive_magmas import AdditiveMagmas\n        axioms = canonicalize_axioms(all_axioms,axioms)\n        base_category = category._without_axioms(named=True)\n        if isinstance(base_category, CategoryWithAxiom): # Smelly runtime type checking\n            result = super(CategoryWithAxiom, base_category)._repr_object_names()\n        else:\n            result = base_category._repr_object_names()\n        for axiom in reversed(axioms):\n            # TODO: find a more generic way to handle the special cases below\n            if axiom in base_category.axioms():\n                # If the base category already has this axiom, we\n                # need not repeat it here. See the example with\n                # Sets().Finite().Subquotients() or Monoids()\n                continue\n            base_category = base_category._with_axiom(axiom)\n            if axiom == \"WithBasis\":\n                result = result.replace(\" over \", \" with basis over \", 1)\n            elif axiom == \"Connected\" and \"graded \" in result:\n                result = result.replace(\"graded \", \"graded connected \", 1)\n            elif axiom == \"Connected\" and \"filtered \" in result:\n                result = result.replace(\"filtered \", \"filtered connected \", 1)\n            elif axiom == \"Endset\" and \"homsets\" in result:\n                # Without the space at the end to handle Homsets().Endset()\n                result = result.replace(\"homsets\", \"endsets\", 1)\n            elif axiom == \"FinitelyGeneratedAsMagma\" and \\\n                 not base_category.is_subcategory(AdditiveMagmas()):\n                result = \"finitely generated \" + result\n            else:\n                result = uncamelcase(axiom) + \" \" + result\n        return result\n\n    def _repr_object_names(self):\n        r\"\"\"\n        The names of the objects of this category, as used by ``_repr_``.\n\n        .. SEEALSO:: :meth:`Category._repr_object_names`\n\n        EXAMPLES::\n\n            sage: FiniteSets()._repr_object_names()\n            'finite sets'\n            sage: AlgebrasWithBasis(QQ).FiniteDimensional()._repr_object_names()\n            'finite dimensional algebras with basis over Rational Field'\n            sage: Monoids()._repr_object_names()\n            'monoids'\n            sage: Semigroups().Unital().Finite()._repr_object_names()\n            'finite monoids'\n            sage: Algebras(QQ).Commutative()._repr_object_names()\n            'commutative algebras over Rational Field'\n\n        .. NOTE::\n\n            This is implemented by taking _repr_object_names from\n            self._without_axioms(named=True), and adding the names\n            of the relevant axioms in appropriate order.\n        \"\"\"\n        return CategoryWithAxiom._repr_object_names_static(self, self.axioms())\n\n    def base_category(self):\n        r\"\"\"\n        Return the base category of ``self``.\n\n        EXAMPLES::\n\n            sage: C = Sets.Finite(); C\n            Category of finite sets\n            sage: C.base_category()\n            Category of sets\n            sage: C._without_axioms()\n            Category of sets\n\n        TESTS::\n\n            sage: from sage.categories.category_with_axiom import TestObjects, CategoryWithAxiom\n            sage: C = TestObjects().Commutative().Facade()\n            sage: assert isinstance(C, CategoryWithAxiom)\n            sage: C._without_axioms()\n            Category of test objects\n        \"\"\"\n        return self._base_category\n\n    def __reduce__(self):\n        r\"\"\"\n        Implement the pickle protocol.\n\n        This overides the implementation in\n        :meth:`UniqueRepresentation.__reduce__` in order to not\n        exposes the implementation detail that, for example, the\n        category of magmas which distribute over an associative\n        additive magma is implemented as\n        ``MagmasAndAdditiveMagmas.Distributive.AdditiveAssociative.AdditiveCommutative``\n        and not\n        ``MagmasAndAdditiveMagmas.Distributive.AdditiveCommutative.AdditiveAssociative``::\n\n        EXAMPLES::\n\n            sage: C = Semigroups()\n            sage: reduction = C.__reduce__(); reduction\n            (<function call_method at ...>, (Category of magmas, '_with_axiom', 'Associative'))\n            sage: loads(dumps(C)) is C\n            True\n            sage: FiniteSets().__reduce__()\n            (<function call_method at ...>, (Category of sets, '_with_axiom', 'Finite'))\n\n            sage: from sage.categories.magmas_and_additive_magmas import MagmasAndAdditiveMagmas\n            sage: C = MagmasAndAdditiveMagmas().Distributive().AdditiveAssociative().AdditiveCommutative()\n            sage: C.__class__\n            <class 'sage.categories.distributive_magmas_and_additive_magmas.DistributiveMagmasAndAdditiveMagmas.AdditiveAssociative.AdditiveCommutative_with_category'>\n            sage: C.__reduce__()\n            (<function call_method at ...>, (Category of additive associative distributive magmas and additive magmas, '_with_axiom', 'AdditiveCommutative'))\n        \"\"\"\n        return (call_method, (self._base_category, \"_with_axiom\", self._axiom))\n\n    @cached_method\n    def _without_axiom(self, axiom):\n        r\"\"\"\n        Return this category, with axiom ``axiom`` removed.\n\n        OUTPUT:\n\n        A category ``C`` which does not have axiom ``axiom`` and such\n        that either ``C`` is ``self``, or adding back all the axioms\n        of ``self`` gives back ``self``.\n\n        .. SEEALSO:: :meth:`Category._without_axiom`\n\n        .. WARNING:: This is not guaranteed to be robust.\n\n        EXAMPLES::\n\n            sage: Groups()._without_axiom(\"Unital\")\n            Category of semigroups\n            sage: Groups()._without_axiom(\"Associative\")\n            Category of inverse unital magmas\n            sage: Groups().Commutative()._without_axiom(\"Unital\")\n            Category of commutative semigroups\n        \"\"\"\n        axioms = self.axioms().difference([axiom])\n        return self._without_axioms()._with_axioms(axioms)\n\n    @cached_method\n    def _without_axioms(self, named=False):\n        \"\"\"\n        Return the category without the axioms that have been\n        added to create it.\n\n        EXAMPLES::\n\n            sage: Sets().Finite()._without_axioms()\n            Category of sets\n            sage: Monoids().Finite()._without_axioms()\n            Category of magmas\n\n        This is because::\n\n            sage: Semigroups().Unital() is Monoids()\n            True\n\n        If ``named`` is ``True``, then ``_without_axioms`` stops at the\n        first category that has an explicit name of its own::\n\n            sage: Sets().Finite()._without_axioms(named=True)\n            Category of sets\n            sage: Monoids().Finite()._without_axioms(named=True)\n            Category of monoids\n\n        Technically we test this by checking if the class specifies\n        explicitly the attribute ``_base_category_class_and_axiom``\n        by looking up ``_base_category_class_and_axiom_origin``.\n\n        Some more examples::\n\n            sage: Algebras(QQ).Commutative()._without_axioms()\n            Category of magmatic algebras over Rational Field\n            sage: Algebras(QQ).Commutative()._without_axioms(named=True)\n            Category of algebras over Rational Field\n        \"\"\"\n        if named and self._base_category_class_and_axiom_origin == \"hardcoded\":\n            return self\n        return self._base_category._without_axioms(named=named)\n\n    @cached_method\n    def axioms(self):\n        r\"\"\"\n        Return the axioms known to be satisfied by all the\n        objects of ``self``.\n\n        .. SEEALSO:: :meth:`Category.axioms`\n\n        EXAMPLES::\n\n            sage: C = Sets.Finite(); C\n            Category of finite sets\n            sage: C.axioms()\n            frozenset({'Finite'})\n\n            sage: C = Modules(GF(5)).FiniteDimensional(); C\n            Category of finite dimensional vector spaces over Finite Field of size 5\n            sage: sorted(C.axioms())\n            ['AdditiveAssociative', 'AdditiveCommutative', 'AdditiveInverse',\n             'AdditiveUnital', 'Finite', 'FiniteDimensional']\n\n            sage: sorted(FiniteMonoids().Algebras(QQ).axioms())\n            ['AdditiveAssociative', 'AdditiveCommutative', 'AdditiveInverse',\n             'AdditiveUnital', 'Associative', 'Distributive',\n             'FiniteDimensional', 'Unital', 'WithBasis']\n            sage: sorted(FiniteMonoids().Algebras(GF(3)).axioms())\n            ['AdditiveAssociative', 'AdditiveCommutative', 'AdditiveInverse',\n             'AdditiveUnital', 'Associative', 'Distributive', 'Finite',\n             'FiniteDimensional', 'Unital', 'WithBasis']\n\n            sage: from sage.categories.magmas_and_additive_magmas import MagmasAndAdditiveMagmas\n            sage: MagmasAndAdditiveMagmas().Distributive().Unital().axioms()\n            frozenset({'Distributive', 'Unital'})\n\n            sage: D = MagmasAndAdditiveMagmas().Distributive()\n            sage: X = D.AdditiveAssociative().AdditiveCommutative().Associative()\n            sage: X.Unital().super_categories()[1]\n            Category of monoids\n            sage: X.Unital().super_categories()[1] is Monoids()\n            True\n        \"\"\"\n        # We would want to write the following line:\n        #     return super(CategoryWithAxiom, self).axioms() | {self._axiom}\n        # However one currently can't use super to call a cached\n        # method in a super class. So we dup the code from there ...\n        return frozenset(axiom\n                         for category in self._super_categories\n                         for axiom in category.axioms()) | {self._axiom}\n\nclass CategoryWithAxiom_over_base_ring(CategoryWithAxiom, Category_over_base_ring):\n\n    def __init__(self, base_category):\n        \"\"\"\n        TESTS::\n\n            sage: C = Modules(ZZ).FiniteDimensional(); C\n            Category of finite dimensional modules over Integer Ring\n            sage: type(C)\n            <class 'sage.categories.modules.Modules.FiniteDimensional_with_category'>\n            sage: type(C).__base__.__base__\n            <class 'sage.categories.category_with_axiom.CategoryWithAxiom_over_base_ring'>\n\n            sage: TestSuite(C).run()\n        \"\"\"\n        # FIXME: this basically duplicates the code from\n        # CategoryWithAxiom.__init__; but we can't call the latter without\n        # calling Category.__init__ twice. One could instead set\n        # \"self.__base\", which is done in Category_over_base_ring.__init__,\n        # but then one has to take into account Python's name mangling.\n        self._base_category = base_category\n        Category_over_base_ring.__init__(self, base_category.base_ring())\n\nclass CategoryWithAxiom_singleton(Category_singleton, CategoryWithAxiom):#, Category_singleton, FastHashable_class):\n    pass\n\n\"\"\"\nThe following workaround is needed until any :class:`CategoryWithAxiom` of a\n:class:`Category_over_base_ring` becomes automatically a\n:class:`CategoryWithAxiom_over_base_ring`::\n\n    sage: from sage.categories.category_with_axiom import TestObjectsOverBaseRing, Category_over_base_ring\n    sage: from sage.categories.category import JoinCategory\n    sage: isinstance(TestObjectsOverBaseRing(QQ), Category_over_base_ring)\n    True\n    sage: C = TestObjectsOverBaseRing(QQ).Commutative()\n    sage: isinstance(C, Category_over_base_ring)          # todo: not implemented\n    True\n    sage: C.FiniteDimensional()\n    Category of finite dimensional commutative test objects over base ring over Rational Field\n    sage: C.Commutative()\n    Category of commutative test objects over base ring over Rational Field\n    sage: C.Unital()\n    Category of commutative unital test objects over base ring over Rational Field\n\n    sage: C = TestObjectsOverBaseRing(IntegerModRing(2)).Connected()\n    sage: isinstance(C, JoinCategory)\n    True\n    sage: isinstance(C, Category_over_base_ring)          # todo: not implemented\n    True\n    sage: C.FiniteDimensional()\n    Category of finite dimensional connected test objects over base ring over Ring of integers modulo 2\n    sage: C.Connected()\n    Category of connected test objects over base ring over Ring of integers modulo 2\n\"\"\"\n\n##############################################################################\n# Utilities and tests tools\n\ndef axiom(axiom):\n    \"\"\"\n    Return a function/method ``self -> self._with_axiom(axiom)``.\n\n    This can used as a shorthand to define axioms, in particular in\n    the tests below. Usually one will want to attach documentation to\n    an axiom, so the need for such a shorthand in real life might not\n    be that clear, unless we start creating lots of axioms.\n\n    In the long run maybe this could evolve into an ``@axiom`` decorator.\n\n    EXAMPLES::\n\n        sage: from sage.categories.category_with_axiom import axiom\n        sage: axiom(\"Finite\")(Semigroups())\n        Category of finite semigroups\n\n    Upon assigning the result to a class this becomes a method::\n\n        sage: class As:\n        ....:     def _with_axiom(self, axiom): return self, axiom\n        ....:     Finite = axiom(\"Finite\")\n        sage: As().Finite()\n        (<__main__.As instance at ...>, 'Finite')\n    \"\"\"\n    def with_axiom(self):\n        return self._with_axiom(axiom)\n    with_axiom.__name__ = axiom\n    return with_axiom\n\nclass Blahs(Category_singleton):\n    r\"\"\"\n    A toy singleton category, for testing purposes.\n\n    This is the root of a hierarchy of mathematically meaningless\n    categories, used for testing Sage's category framework:\n\n    - :class:`Bars`\n    - :class:`TestObjects`\n    - :class:`TestObjectsOverBaseRing`\n    \"\"\"\n\n    def super_categories(self):\n        \"\"\"\n        TESTS::\n\n             sage: from sage.categories.category_with_axiom import Blahs\n             sage: Blahs().super_categories()\n             [Category of sets]\n             sage: TestSuite(Blahs()).run()\n        \"\"\"\n        from sage.categories.sets_cat import Sets\n        return [Sets()]\n\n    class SubcategoryMethods:\n        FiniteDimensional = axiom(\"FiniteDimensional\")\n        Commutative       = axiom(\"Commutative\")\n        Unital            = axiom(\"Unital\")\n        Connected         = axiom(\"Connected\")\n        Flying            = axiom(\"Flying\")\n        Blue              = axiom(\"Blue\")\n\n    class FiniteDimensional(CategoryWithAxiom):\n        pass\n    class Commutative(CategoryWithAxiom):\n        pass\n    class Connected(CategoryWithAxiom):\n        pass\n    class Unital(CategoryWithAxiom):\n        class Blue(CategoryWithAxiom):\n            pass\n    class Flying(CategoryWithAxiom):\n        def extra_super_categories(self):\n            \"\"\"\n            This illustrates a way to have an axiom imply another one.\n\n            Here, we want ``Flying`` to imply ``Unital``, and to put\n            the class for the category of unital flying blahs in\n            ``Blahs.Flying`` rather than ``Blahs.Unital.Flying``.\n\n            TESTS::\n\n                sage: from sage.categories.category_with_axiom import Blahs, TestObjects, Bars\n                sage: Blahs().Flying().extra_super_categories()\n                [Category of unital blahs]\n                sage: Blahs().Flying()\n                Category of flying unital blahs\n            \"\"\"\n            return [Blahs().Unital()]\n\n    def Blue_extra_super_categories(self):\n        \"\"\"\n        Illustrates a current limitation in the way to have an axiom\n        imply another one.\n\n        Here, we would want ``Blue`` to imply ``Unital``, and to put\n        the class for the category of unital blue blahs in\n        ``Blahs.Unital.Blue`` rather than ``Blahs.Blue``.\n\n        This currently fails because ``Blahs`` is the category where\n        the axiom ``Blue`` is defined, and the specifications\n        currently impose that a category defining an axiom should also\n        implement it (here in an category with axiom\n        ``Blahs.Blue``). In practice, due to this violation of the\n        specifications, the axiom is lost during the join calculation.\n\n        .. TODO::\n\n            Decide whether we care about this feature. In such a\n            situation, we are not really defining a new axiom, but\n            just defining an axiom as an alias for a couple others,\n            which might not be that useful.\n\n        .. TODO::\n\n            Improve the infrastructure to detect and report this\n            violation of the specifications, if this is\n            easy. Otherwise, it's not so bad: when defining an axiom A\n            in a category ``Cs`` the first thing one is supposed to\n            doctest is that ``Cs().A()`` works. So the problem should\n            not go unnoticed.\n\n        TESTS::\n\n            sage: from sage.categories.category_with_axiom import Blahs, TestObjects, Bars\n            sage: Blahs().Blue_extra_super_categories()\n            [Category of unital blahs]\n            sage: Blahs().Blue()                          # todo: not implemented\n            Category of blue unital blahs\n        \"\"\"\n        return [Blahs().Unital()]\n\nclass Bars(Category_singleton):\n    r\"\"\"\n    A toy singleton category, for testing purposes.\n\n    .. SEEALSO:: :class:`Blahs`\n    \"\"\"\n\n    def super_categories(self):\n        \"\"\"\n        TESTS::\n\n            sage: from sage.categories.category_with_axiom import Bars\n            sage: Bars().super_categories()\n            [Category of blahs]\n            sage: TestSuite(Bars()).run()\n        \"\"\"\n        return [Blahs()]\n\n    def Unital_extra_super_categories(self):\n        \"\"\"\n        Return extraneous super categories for the unital objects of ``self``.\n\n        This method specifies that a unital bar is a test object.\n        Thus, the categories of unital bars and of unital test objects\n        coincide.\n\n        EXAMPLES::\n\n            sage: from sage.categories.category_with_axiom import Bars, TestObjects\n            sage: Bars().Unital_extra_super_categories()\n            [Category of test objects]\n            sage: Bars().Unital()\n            Category of unital test objects\n            sage: TestObjects().Unital().all_super_categories()\n            [Category of unital test objects,\n             Category of unital blahs,\n             Category of test objects,\n             Category of bars,\n             Category of blahs,\n             Category of sets,\n             Category of sets with partial maps,\n             Category of objects]\n        \"\"\"\n        return [TestObjects()]\n\nclass TestObjects(Category_singleton):\n    r\"\"\"\n    A toy singleton category, for testing purposes.\n\n    .. SEEALSO:: :class:`Blahs`\n    \"\"\"\n\n    def super_categories(self):\n        \"\"\"\n        TESTS::\n\n            sage: from sage.categories.category_with_axiom import TestObjects\n            sage: TestObjects().super_categories()\n            [Category of bars]\n            sage: TestSuite(TestObjects()).run()\n        \"\"\"\n        return [Bars()]\n\n    class FiniteDimensional(CategoryWithAxiom):\n         class Finite(CategoryWithAxiom):\n              pass\n         class Unital(CategoryWithAxiom):\n              class Commutative(CategoryWithAxiom):\n                   pass\n\n    class Commutative(CategoryWithAxiom):\n         class Facade(CategoryWithAxiom):\n             pass\n         class FiniteDimensional(CategoryWithAxiom):\n             pass\n         class Finite(CategoryWithAxiom):\n             pass\n\n    class Unital(CategoryWithAxiom):\n        pass\n\nclass TestObjectsOverBaseRing(Category_over_base_ring):\n    r\"\"\"\n    A toy singleton category, for testing purposes.\n\n    .. SEEALSO:: :class:`Blahs`\n    \"\"\"\n\n    def super_categories(self):\n        \"\"\"\n        TESTS::\n\n            sage: from sage.categories.category_with_axiom import TestObjectsOverBaseRing\n            sage: TestObjectsOverBaseRing(QQ).super_categories()\n            [Category of test objects]\n            sage: TestObjectsOverBaseRing.Unital.an_instance()\n            Category of unital test objects over base ring over Rational Field\n            sage: TestObjectsOverBaseRing.FiniteDimensional.Unital.an_instance()\n            Category of finite dimensional unital test objects over base ring over Rational Field\n            sage: TestSuite(TestObjectsOverBaseRing(QQ).FiniteDimensional().Unital().Commutative()).run()\n        \"\"\"\n        return [TestObjects()]\n\n    class FiniteDimensional(CategoryWithAxiom_over_base_ring):\n         class Finite(CategoryWithAxiom_over_base_ring):\n              pass\n         class Unital(CategoryWithAxiom_over_base_ring):\n              class Commutative(CategoryWithAxiom_over_base_ring):\n                   pass\n\n    class Commutative(CategoryWithAxiom_over_base_ring):\n         class Facade(CategoryWithAxiom_over_base_ring):\n             pass\n         class FiniteDimensional(CategoryWithAxiom_over_base_ring):\n             pass\n         class Finite(CategoryWithAxiom_over_base_ring):\n             pass\n\n    class Unital(CategoryWithAxiom_over_base_ring):\n        pass\n\n", "meta": {"hexsha": "fc5e45bb9b88cc5e6953d8e4e584761062ab5595", "size": 112270, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/categories/category_with_axiom.py", "max_stars_repo_name": "defeo/sage", "max_stars_repo_head_hexsha": "d8822036a9843bd4d75845024072515ede56bcb9", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/sage/categories/category_with_axiom.py", "max_issues_repo_name": "defeo/sage", "max_issues_repo_head_hexsha": "d8822036a9843bd4d75845024072515ede56bcb9", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/categories/category_with_axiom.py", "max_forks_repo_name": "defeo/sage", "max_forks_repo_head_hexsha": "d8822036a9843bd4d75845024072515ede56bcb9", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.254571531, "max_line_length": 167, "alphanum_fraction": 0.6767079362, "include": true, "reason": "import sage,from sage", "num_tokens": 26255, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.476579651063676, "lm_q2_score": 0.14414885303274058, "lm_q1q2_score": 0.06869841007957261}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     cell_metadata_filter: all\n#     notebook_metadata_filter: all,-language_info,-toc,-latex_envs\n#     text_representation:\n#       extension: .py\n#       format_name: percent\n#       format_version: '1.3'\n#       jupytext_version: 1.6.1-dev\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# %%\nimport copy\nimport datetime\nimport pprint\nfrom pathlib import Path\n\nimport cartopy\nimport cartopy.crs\nimport geopandas as gpd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pytz\nimport rasterio\nfrom IPython.display import display\nfrom matplotlib import pyplot as plt\nfrom matplotlib.colors import Normalize\nfrom pyproj import CRS, Transformer\n\n# %%\nimport a301_lib\n\npacific = pytz.timezone(\"US/Pacific\")\ndate = datetime.datetime.today().astimezone(pacific)\nprint(f\"written on {date}\")\n\n# %% [markdown]\n# (assign6b_sol)=\n# # Solution: adding an image with features to a cartopy map\n#\n# Here's a demo of adding features to an image.  The notebook does some extra work to\n# illustrate how to make a map that is bigger than the image, and how to reproject from\n# one raster crs to another using rasterio.\n#\n# 1) read in the `vancouver_345_refl.tiff` band 5 image  \n# 2) find the image corners in utm10 and geodetic lat/lon (for the features)  \n# 3) put the image on a map that extends 5 km beyond the image  \n# 4) add the features to the big map  \n# 5) create a new crs that is laea centered on lat=50 deg N, lon= -120 deg E  \n# 6) use rasterio.reproject to reproject the utm10 image onto the laea crs  \n# 7) draw a 50 row by 100 column box on the image\n\n# %% [markdown]\n# ## Read in the geotiff\n#\n# First read in band 5 from the `vancouver_345_refl.tiff` image that was produced by\n# {ref}`rasterio_3bands`:\n\n# %%\nnotebook_dir = a301_lib.data_share.resolve()\nprint(notebook_dir)\nweek10_scene = notebook_dir / \"vancouver_345_refl.tiff\"\n\n# %%\nwith rasterio.open(week10_scene) as van_raster:\n    b5_refl = van_raster.read(3)\n    chan3_tags = van_raster.tags(3)\n    crs_10 = van_raster.profile[\"crs\"]\n    profile=van_raster.profile\n    affine_transform = profile[\"transform\"]\n    tags = van_raster.tags()\n    print(f\"\\n\\n{tags=}, \\n\\n{chan3_tags=},\\n\\n {profile=},\\n\\n {affine_transform=}\\n\")\n\n# %% [markdown]\n# ## Set up the lat/lon UTM10N transform\n#\n# I'll want to transform back and forth between UTM and lat/lon (since I think in lat/lon), so create\n# a transformer object for this.  Copy code from {ref}`image_zoom`\n\n# %%\nfrom pyproj import CRS, Transformer\n\np_utm10 = crs_10\np_latlon = CRS.from_epsg(4326)\ncrs_transform = Transformer.from_crs(p_latlon, p_utm10)\nprint(p_latlon.to_wkt())\n\n# %% [markdown]\n# ## Find the corners of the image\n#\n# I need the upper left and lower right corners to set the image extent for imshow.  This is\n# what the affine transform provides.  I'll use my crs_transform to also get the image_extent\n# in lon/lat coords to make sure I'm in the right place\n\n# %%\nul_x_utm10, ul_y_utm10 = affine_transform*(0,0)\nlr_x_utm10, lr_y_utm10 = affine_transform*(profile['width'],profile['height'])\nprint(f\"{(ul_x_utm10,ul_y_utm10,lr_x_utm10,lr_y_utm10)=}\")\nimage_extent_utm10 = (ul_x_utm10,lr_x_utm10, lr_y_utm10, ul_y_utm10)\n\n# %%\nul_lon,ul_lat = crs_transform.transform(ul_x_utm10,ul_y_utm10,direction='INVERSE')\nlr_lon,lr_lat = crs_transform.transform(lr_x_utm10,lr_y_utm10,direction='INVERSE')\nprint(f\"{(ul_lon,ul_lat,lr_lon,lr_lat)=}\")\n\n# %% [markdown]\n# ## Make the map extent bigger than the image\n#\n# In order show more context, I'll enlarge the map extent by 5 km on each size\n\n# %%\nmap_ul_x = ul_x_utm10 - 5.e3\nmap_lr_x = lr_x_utm10 + 5.e3\nmap_ul_y = ul_y_utm10 + 5.e3\nmap_lr_y = lr_y_utm10 - 5.e3\nmap_extent_utm10 = (map_ul_x,map_lr_x,map_lr_y,map_ul_y)\nprint(f\"{map_extent_utm10=}\")\n\n# %% [markdown]\n# * Repeat the imshow code from {ref}`rasterio_3bands`:\n\n# %%\ncartopy_utm10 = cartopy.crs.epsg(crs_10.to_epsg())\nfig, ax = plt.subplots(\n        1, 1, figsize=(15,15), subplot_kw={\"projection\": cartopy_utm10}\n    )\n\nvmin = 0.0\nvmax = 0.4\nthe_norm = Normalize(vmin=vmin, vmax=vmax, clip=False)\npalette = \"viridis\"\npal = copy.copy(plt.get_cmap(palette))\npal.set_bad(\"0.75\")  # 75% grey for out-of-map cells\npal.set_over(\"w\")  # color cells > vmax red\npal.set_under(\"k\")  # color cells < vmin black\ncol=ax.imshow(b5_refl, cmap=pal, norm=the_norm, origin=\"upper\",\n          extent=image_extent_utm10,transform=cartopy_utm10);\ncbar_ax = fig.add_axes([0.85, 0.2, 0.05, 0.6])\ncbar = ax.figure.colorbar(col, extend=\"both\", cax=cbar_ax, orientation=\"vertical\")\ncbar.set_label(\"band 5 reflectance\")\n\n# %% [markdown]\n# ## Now set the map extent\n#\n# From the {ref}`demo_cartopy_extent` notebook we can repeat the ax.set_extent call to make the map\n# larger than the image\n\n# %%\nax.set_extent(map_extent_utm10,crs=cartopy_utm10)\ndisplay(fig)\n\n# %% [markdown]\n# ## Add features\n#\n# Use the {ref}`subset_map` code to put features on this axis.  I need the cartopy_latlon\n# crs to do this (since p_latlon, the pyproj crs, doesn't work with cartopy)\n\n# %%\ngpd_dict = {}\nread_files=True\nif read_files:\n    all_cia = a301_lib.data_share / \"openstreetmap/WDBII_shp/f\"\n    all_cia = list(all_cia.glob(\"*\"))\n    for item in all_cia:\n        gpd_dict[item.name] = gpd.read_file(item)\n        print(f\"read {item.name}\")\n\n    all_gshhs = a301_lib.data_share / \"openstreetmap/GSHHS_shp/f\"\n    all_gshhs = list(all_gshhs.glob(\"*\"))\n\n    for item in all_gshhs:\n        gpd_dict[item.name] = gpd.read_file(item)\n        print(f\"read {item.name}\")\nelse:\n    shape_files = list(small_shapes.glob(\"*\"))\n    for item in shape_files:\n        key = item.stem\n        gpd_dict[key] = gpd.read_file(item)\n        print((f\"reading saved shapefile {item} with\\n\"\n               f\"{len(gpd_dict[key])} rows\"))\n\n\n# %%\ndef find_features(extent, df):\n    \"\"\"\n    given an extent and a dataframe, return a new dataframe\n    containing only features that fall within the extent\n\n    Parameters\n    ----------\n\n    extent:  list -- geographic extent in lon (deg E)/lat (deg N)\n    df:  the geopandas dataframe to slice\n    \"\"\"\n    xleft, xright, ybot, ytop = extent\n    hit_rows = df.cx[xleft:xright, ybot:ytop]\n    return hit_rows\n\nextent = [-124, -122, 48, 50]\nif read_files:\n    subset_dict = {}\n    for key, df in gpd_dict.items():\n        df_subset = find_features(extent, df)\n        if len(df_subset) > 0:\n            subset_dict[key] = df_subset\n            print(f\"clipping {key}\")\nelse:\n    subset_dict=gpd_dict\n\n# %% [markdown]\n# * now put the features on -- they are defined in geodetic (lat/lon) crs\n\n# %%\ncartopy_latlon = cartopy.crs.PlateCarree()\nfor key, df in subset_dict.items():\n    print(f\"adding {key} with {len(df)} features\")\n    if key.find(\"river\") > -1:\n        ax.add_geometries(\n            df[\"geometry\"], cartopy_latlon, facecolor=\"none\", edgecolor=\"green\",lw=3,\n        )\n    else:\n        ax.add_geometries(\n            df[\"geometry\"], cartopy_latlon, facecolor=\"none\", edgecolor=\"blue\",lw=3,\n        )\ndisplay(fig)\n\n# %% [markdown]\n# ## Putting images from different utm zones on a map\n#\n# (not part of the assignment)\n#\n# Suppose you're working on a project that spans BC and Alberta, and you need\n# to put images on a map that are either UTM zone 10 (-126 to -120 deg E) or\n# UTM zone 11 (-120 to - 114 deg E).  To show both images on the same map, you\n# need to reproject them onto a common crs. As a compromise, let's use a laea\n# projection centered on `lon_0`= -120 deg E, `lat_0`=50 deg N\n#\n# Here are the rasterio reprojection module docs: [rasterio](https://rasterio.readthedocs.io/en/latest/topics/reproject.html)\n#\n# ### Step 1 is to create [the new pyproj crs](https://pyproj4.github.io/pyproj/dev/api/crs/crs.html).\n#\n# I'll just borrow the pyproj parameters from our earlier notebooks.\n\n# %%\nlat_0=50\nlon_0 = -120\nlaea_proj = {'datum': 'WGS84', 'lat_0': '50', 'lon_0': '-120', 'no_defs': 'None',\n             'proj': 'laea', 'type': 'crs', 'units': 'm', 'x_0': '0', 'y_0': '0'}\np_laea = CRS(laea_proj)\np_laea.to_wkt()\n\n# %% [markdown]\n# ### Step 2 is to reproject the extent in the new coordinate system\n#\n# Remember that extent order is:  [xleft, xright, ybot, ytop].  We need to get these values in the new laea crs.\n#\n# Here are the two extents for the image\"\n\n# %%\ncrs_transform = Transformer.from_crs(p_utm10, p_laea)\nextent_utm10 = [ul_x_utm10,lr_x_utm10,lr_y_utm10,ul_y_utm10]\nul_x_laea,ul_y_laea = crs_transform.transform(ul_x_utm10,ul_y_utm10)\nlr_x_laea,lr_y_laea = crs_transform.transform(lr_x_utm10,lr_y_utm10)\nextent_laea=[ul_x_laea,lr_x_laea,lr_y_laea,ul_y_laea]\nprint(f\"{extent_utm10=}\")\nprint(f\"{extent_laea=}\")\n\n# %% [markdown]\n# ### step 3: create the affine transform\n#\n# We need the pixel size, then we can use the Affine constructor as we did in {ref}`image_zoom`\n# (don't forget to make the pixel height negative). Notice that the pixel size has\n# changed slightly in the laea crs.  Also notice that the correct denominator is (#pixels - 1), not #pixels.  That's\n# because the extents go from the left side of the first pixel to the right side of the last pixel.  Dividing\n# by #pixels would put the right boundary 1 pixel less than it needs to be.\n\n# %%\npixel_x_size = (lr_x_laea - ul_x_laea)/(profile['width'] -1)\npixel_y_size = (ul_y_laea - lr_y_laea)/(profile['height'] - 1)\nprint(f\"{pixel_x_size=},{pixel_y_size=}\")\n\n# %%\nfrom affine import Affine\n\nlaea_affine = Affine(pixel_x_size,0,ul_x_laea,0,-pixel_y_size,ul_y_laea)\n\n# %% [markdown]\n# ### step 4: do the reprojection from p_utm10 to p_laea\n#\n# First make a numpy array to hold the reprojected image.  We're keeping the row and column numbers the same as i the original tiff.\n\n# %%\nwidth=profile['width']\nheight=profile['height']\nb5_refl_laea = np.ones([height,width],dtype=np.float32)\n\n# %% [markdown]\n# ### Now reproject from utm10 to laea\n\n# %%\nfrom rasterio.warp import Resampling, reproject\n\nreproject(\n        b5_refl,\n        b5_refl_laea,\n        src_transform=affine_transform,\n        src_crs=p_utm10,\n        dst_transform=laea_affine,\n        dst_crs=p_laea,\n        resampling=Resampling.nearest);\nplt.imshow(b5_refl_laea);\n\n# %% [markdown]\n# ### step 5: Make a cartopy map\n#\n# As of cartopy 0.18 we also need to create a cartopy version of the laea crs,\n# since it doesn't accept the pyproj version.   See [cartopy projections](https://scitools.org.uk/cartopy/docs/latest/crs/projections.html#cartopy-projections).  One difference is\n# that cartopy requires that the datum be specified separately from the projection, using a `globe` object.\n# You can track progress on making cartopy more compatible with pyproj [here](https://github.com/SciTools/cartopy/pull/1023#discussion_r168395702) [and here](https://github.com/SciTools/cartopy/issues/1477)\n\n# %%\ndir(cartopy.crs.CRS)\nglobe = cartopy.crs.Globe(datum='WGS84',ellipse='WGS84')\nlaea_cartopy_crs = cartopy.crs.LambertAzimuthalEqualArea(central_longitude=lon_0,\n                                                    central_latitude=lat_0,\n                                                    globe=globe)\nprint(f\"proj4 string: {laea_cartopy_crs.proj4_init=}\")\n\n# %% [markdown]\n# **now plot it with features**\n#\n# Note the boundaries are slightly skewed at the top and bottom of the reprojection. In the laea projection all locations are referenced to the point at (`lon_`,`lat_0`), while for the UTM projection all locations are referenced to the longitude line going through the middle of the zone. The UTM preserves angles and shapes over small regions (i.e. it's conformal), but the scale changes with location.  The laea preserves scale, but distorts angles and shapes.  See [wikpedia lambert](https://en.wikipedia.org/wiki/Lambert_azimuthal_equal-area_projection) and [wikipedia conformal](https://en.wikipedia.org/wiki/Conformal_map_projection)\n\n# %%\nfig, ax = plt.subplots(\n        1, 1, figsize=(10,15), subplot_kw={\"projection\": laea_cartopy_crs}\n    )\n\nvmin = 0.0\nvmax = 0.4\nthe_norm = Normalize(vmin=vmin, vmax=vmax, clip=False)\npalette = \"viridis\"\npal = copy.copy(plt.get_cmap(palette))\npal.set_bad(\"0.75\")  # 75% grey for out-of-map cells\npal.set_over(\"w\")  # color cells > vmax red\npal.set_under(\"k\")  # color cells < vmin black\ncol=ax.imshow(b5_refl_laea, cmap=pal, norm=the_norm, origin=\"upper\",\n          extent=extent_laea,transform=laea_cartopy_crs)\ncbar_ax = fig.add_axes([0.90, 0.2, 0.05, 0.6])\ncbar = ax.figure.colorbar(col, extend=\"both\", cax=cbar_ax, orientation=\"vertical\")\ncbar.set_label(\"band 5 reflectance\")\n\n# %% [markdown]\n# ### Add a coastline/rivers\n\n# %%\nfor key, df in subset_dict.items():\n    print(f\"adding {key} with {len(df)} features\")\n    if key.find(\"river\") > -1:\n        ax.add_geometries(\n            df[\"geometry\"], cartopy_latlon, facecolor=\"none\", edgecolor=\"red\",lw=5,\n        )\n    else:\n        ax.add_geometries(\n            df[\"geometry\"], cartopy_latlon, facecolor=\"none\", edgecolor=\"blue\",lw=3,\n        )\ndisplay(fig)\n\n# %% [markdown]\n# ## draw a red box in the middle of the scene\n#\n# We want a box that's 50 rows by 100 columns. I'll center it at row 300, column 200, and move up 25 rows and\n# down 50 rows to find the corners.\n\n# %%\nul_x, ul_y = laea_affine*(150,275)\nlr_x, lr_y = laea_affine*(250,325)\ndelta_x = lr_x - ul_x\ndelta_y = ul_y - lr_y\nprint(f\"{(ul_x,ul_y,lr_x,lr_y)=}\")\n#\n# circle clockwise from upper left corner\n#\nbox_x = [ul_x, ul_x + delta_x, ul_x + delta_x, ul_x,          ul_x]\nbox_y = [ul_y, ul_y          , ul_y - delta_y, ul_y - delta_y,ul_y]\nax.plot(box_x,box_y,'r-',lw=4)\ndisplay(fig)\n\n# %% [markdown]\n# ## More mapping tools for meteorology\n#\n# Check out [metpy](https://unidata.github.io/MetPy/latest/examples/index.html#plotting) for meteorologically oriented maps.\n", "meta": {"hexsha": "5b7d98eecaee9fcc1149a96ee7057968ef65067a", "size": 13714, "ext": "py", "lang": "Python", "max_stars_repo_path": "week11/assign6b_sol.py", "max_stars_repo_name": "phaustin/a301_2020", "max_stars_repo_head_hexsha": "9be7ead5f641013e2cec4e736ea76171b849e8d5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-26T03:59:16.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-26T03:59:16.000Z", "max_issues_repo_path": "week11/assign6b_sol.py", "max_issues_repo_name": "phaustin/a301_2020", "max_issues_repo_head_hexsha": "9be7ead5f641013e2cec4e736ea76171b849e8d5", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "week11/assign6b_sol.py", "max_forks_repo_name": "phaustin/a301_2020", "max_forks_repo_head_hexsha": "9be7ead5f641013e2cec4e736ea76171b849e8d5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-02-01T09:55:18.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-01T09:55:18.000Z", "avg_line_length": 34.4572864322, "max_line_length": 639, "alphanum_fraction": 0.6976082835, "include": true, "reason": "import numpy", "num_tokens": 4117, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41489883132727684, "lm_q2_score": 0.16451646699291617, "lm_q1q2_score": 0.06825768988945344}}
{"text": "#!/usr/bin/python\n\n'''\nNUI Galway CT5132/CT5148 Programming and Tools for AI (James McDermott)\n\nSolution for Assignment 3:  Hand-coding solutions for the Abstraction\n                            and Reasoning Corpus\n\nBy writing my name below and submitting this file, I/we declare that\nall additions to the provided skeleton file are my/our own work, and\nthat I/we have not seen any work on this assignment by another\nstudent/group.\n\nStudent name(s):    John Doyle\nStudent ID(s):      21230978\nGitHub:             https://github.com/john9d/ARC\n\nSummary of the ARC Assignment:\n\nThe solve_* solutions completed below were completed using basic python functions\nand no machine learning techniques, with the majority using only the built in Python\nfunctions. Such as for loops, if else statements and enumerate. The math library was\nused for an irrational number and the numpy library for mainly array specific functions.\n\nMost of the solve_* solution started with a loop pass through the array and getting the\nindex of specific number required to solve the task. Then mainly replacing this with the\ncorrect number, some requiring to reshape. Where possible the solve_* solutions tried to\nuse techniques that would help solve the solution in different size array that the tasks\nshown.\n\nBelow the term \"colour\" is used primarily, as the ARC testing_interface.html was used\nto identify/describe the task and its solution.\n\n\n'''\n\n\n\nimport os, sys\nimport json\nimport numpy as np\nimport re\nimport math\n\n\n### YOUR CODE HERE: write at least three functions which solve\n### specific tasks by transforming the input x and returning the\n### result. Name them according to the task ID as in the three\n### examples below. Delete the three examples. The tasks you choose\n### must be in the data/training directory, not data/evaluation.\n\ndef solve_22eb0ac0(x):\n    '''\n    ########################### SOLUTION No.1 ###############################\n    #Using the ARC testing interface Task 22eb0ac0 shows a 10x10 array where there\n    #are a number of colours vertically aligned and opposing each other on the\n    #left and right side of the array. The task solutions show an array where the\n    #a row in the array is filled in wth a colour that had a match of colour on the\n    #left and right hand side. Any colours that do not match, will leave the row\n    #black in between.\n\n    #To solve this task we will need iterate through the array to adn create an if\n    #statement to see if the start of the row and the end of the row match. If this\n    #is true, we will enumerate the row, identify and replace all of the colours in\n    #between with the match left and right colour.\n    '''\n    # Initiate loop through the array\n    for i in x:\n\n        # We will now check for the matching numbers\n        if i[0] == i[-1]:\n\n            # We will need to store the number so we can replace the non-matching ones\n            value = i[0]\n\n            # We will store the non-matching number\n            item = i[1]\n\n            # Enumerate through the row and create an index of the non-matching values\n            index = [j for j, y in enumerate(i) if y == item]\n\n            # We will now loop through the index list so we can replace this values\n            for a in index:\n\n                # This will now replace the non-matching values\n                i[a] = value\n\n    return x\n\ndef solve_0d3d703e(x):\n    '''\n    ########################### SOLUTION No.2 ###############################\n    #Using the ARC testing interface Task 0d3d703e shows a 3x3 array of 3 colours,\n    #all vertically aligned. Each colour is converted in the solution i.e. green to\n    #yellow, blue to grey, etc. and the conversion is mirrored i.e. yellow to green,\n    #grey to blue, etc. The test task has an array of light blue, blue and green all\n    #of which need to be converted to wine, grey and yellow respectively.\n\n    #To solve this task we will need to convert each colour (number), however there\n    #are overlaps in colours. If we attempt to simply convert each number to its\n    #solved state, the number will be reconverted back i.e. when updating 1 to 5, next\n    #in the array we are required to update 5 to 1. This will return the old number.\n    #To avoid this, we are going to divide by an irrational number (pi in this case)\n    #so we can avoid double conversion. Post this, we will multiple the array by pi and\n    #perform floor division to remove a chance of a floating point error.\n    '''\n\n    # We are going search the array and covert 1 to 5 and divide by pi\n    x = np.where(x == 1, 5/math.pi, x)\n\n    # We are going search the array and covert 2 to 6 and divide by pi\n    x = np.where(x == 2, 6/math.pi, x)\n\n    # We are going search the array and covert 3 to 4 and divide by pi\n    x = np.where(x == 3, 4/math.pi, x)\n\n    # We are going search the array and covert 4 to 3 and divide by pi\n    x = np.where(x == 4, 3/math.pi, x)\n\n    # We are going search the array and covert 6 to 2 and divide by pi\n    x = np.where(x == 6, 2/math.pi, x)\n\n    # We are going search the array and covert 8 to 9 and divide by pi\n    x = np.where(x == 8, 9/math.pi, x)\n\n    # We are going search the array and covert 5 to 1 and divide by pi\n    x = np.where(x == 5, 1/math.pi, x)\n\n    # We are going search the array and covert 9 to 8 and divide by pi\n    x = np.where(x == 9, 8/math.pi, x)\n\n    # We are going now multiply the array by pi and perform a floor division\n    # This will return remove the floating point error\n    x = (x*math.pi)//1\n\n    return x\n\ndef solve_ce4f8723(x):\n    '''\n    ########################### SOLUTION No.3 ###############################\n    #Using the ARC testing interface Task ce4f8723 shows a 9x4 array. Where there\n    #are two 4x4 arrays with coloured and black squares, separated by a 1x4 array\n    #to divide the two 4x4 arrays. The results of each task demonstrate that when\n    #overlay the two 4x4 arrays, the resulting array shows only black squares in\n    #the resulting 4x4 array where both have them. Colouring all of the other squares\n    #in a different colour (green!)\n\n    #To solve this task we will need to identify the shape of the array, and then we will\n    #flatten the array to (1, N), where N is the total number of items in the array. As\n    #we need to combine the two 4x4 coloured arrays we will then split the (1,N) array\n    #into two, removing the dividing array. We shall then add the two arrays together and\n    #then enumerate it to find where there are black colours (0). We then replace the\n    #black (non-zero) with the green and reshape to the correct format for the output.\n    '''\n\n\n    # First we need to define the shape of the array being assessed using .shape\n    h, w = x.shape\n\n    # Then we need to flatten nDimension out the array to a (1, N) array\n    y = x.ravel()\n\n    # We need to split out the top array of colours from 0 to the width times the width\n    # index in the flatten array. This will future proof should we any other NxN array\n    y1 = y[0:(w*w)]\n\n    # We will split out the bottom array of colours, removing the 1x4 array by starting\n    # the index at width times the width plus the width\n    y2 = y[(w*w+w):]\n\n    # Add the two arrays together so we can identify the black (zeros)\n    y_total = (y1+y2)\n\n    # Set the value for the green output colour\n    value = 3\n\n    # Enumerate through the list to identify the zeros in the combined arrays\n    index = [j for j, a in enumerate(y_total) if a != 0]\n\n    # We now need to iterate through the list of non-zeros\n    for b in index:\n\n        # Replacing the values with the green (3)\n        y_total[b] = value\n\n    # Now we will reshape the (1, N) array back to the correct shape\n    x = y_total.reshape(w, -w)\n\n    return x\n\ndef solve_e26a3af2(x):\n    '''\n    ########################### SOLUTION No.4 ###############################\n    #Using the ARC testing interface Task e26a3af2 shows a varying NxM arrays.\n    #Where some of the arrays N = M. In each of the tasks, there is either a\n    #vertical or horizontal lines of varying width containing primarily 3 or 4\n    #colours (numbers), with a random placement of any colour throughout. Each\n    #task solution clears out the random colours and leaves a neat 3 or 4 colour\n    #lines. The test grid is 5 colours in a horizontal arrangement.\n\n    #To solve the task we will enumerate the array and identify the mode colour\n    #in each row of the array, inorder to create a new NxM array in clean of any\n    #random colours. This will work with the horizontally aligned colours easily,\n    #however we will need to transpose the array for the vertically aligned colours.\n    #An if statement that will assess if the mode is greater than 1/2 of the array\n    #width (as all arrays have 3 or more colours) will be able to ensure the mode\n    #and array will be correctly reformed.\n    '''\n\n\n    # We need to create an empty list for mode colour in each row\n    mode = []\n\n    # We need to create an empty list for maximum number of colours in each row\n    # This will allow us to verify if we need to transpose the array\n    total = []\n\n    # Gather the height and width of the array so we can create the new array correctly\n    h, w = x.shape\n\n    # We will enumerate x to identify the the mode colour in each row\n    for i, j in enumerate(x):\n\n        # Create a list of each value and count of each to identify the mode\n        vals, counts = np.unique(x[i], return_counts=True)\n\n        # Capture the value tha made the colour the mode\n        total = max(counts)\n\n        # Create an location index for the value which is the mode\n        index = np.argmax(counts)\n\n        # Store the mode in the row\n        c = vals[index]\n\n        # Append the mode to the global list\n        mode = np.append(mode, [c], axis=0)\n\n    # We will now transpose the array and complete the same tasks as above\n    # We need to create an empty list for mode colour in each row\n    x_T = x.T\n\n    # We need to create an empty list for maximum number of colours in each row\n    # This will allow us to verify if we need to transpose the array\n    mode_T = []\n\n    # Gather the height and width of the array so we can create the new array correctly\n    h_T, w_T = x_T.shape\n\n    # We will enumerate x to identify the the mode colour in each row\n    for i_T, j_T in enumerate(x_T):\n\n        # Create a list of each value and count of each to identify the mode\n        vals_T, counts_T = np.unique(x_T[i_T], return_counts=True)\n\n        # Create an location index for the value which is the mode\n        index_T = np.argmax(counts_T)\n\n        # Store the mode in the row\n        c_T = vals_T[index_T]\n\n        # Append the mode to the global list\n        mode_T = np.append(mode_T, [c_T], axis=0)\n\n    # Create an if statement to verify if we are working with a vertical task\n    if total < w/2:\n        ##The mode is less than half the count so we will use the transposed array##\n        # Create an empty numpy array\n        f_T = np.array([])\n\n        # Iterate through the global mode list created\n        for i in mode_T:\n            # Append each mode value as a new row and multiply it by the width of\n            # of the original transposed array\n            f_T = np.append(f_T, [i] * w_T, axis=0)\n\n        # Reshape the new array to the original transposed array\n        r = f_T.reshape(h_T, w_T)\n\n        # Transpose the new array back to its original shape\n        x = r.T\n\n    # Else we are now working with a horizontal type task\n    else:\n        ##The mode is more than half the count so we will use the normal array##\n        # Create an empty numpy array\n        f = np.array([])\n\n        # Iterate through the global mode list created\n        for i in mode:\n\n            # Append each mode value as a new row and multiply it by the width of\n            # of the original array\n            f = np.append(f, [i] * w, axis=0)\n\n        # Reshape the new array to the original array\n        x = f.reshape(h, w)\n\n    return x\n\ndef solve_9ecd008a(x):\n    '''\n    ########################### SOLUTION No.5 ###############################\n    Using the ARC testing interface Task 9ecd008 shows a large 20x20 array.\n    All with a pattern of different colours. Each task has a small 3x3 array with\n    colour missing, the solution for each task is to create a 3x3 of the missing\n    colours in the correct pattern. As each pattern is mirrored on x and y axes where\n    10x20 = 10x20 and 20x10 = 20x10, the missing pattern is its mirror on the y axis\n    in each task.\n\n    To solve the task we will enumerate the array and identify which rows contain\n    a black (zero) square by calculating the length of the row with no black. If\n    the row has black square, we will pass this into another loop to enumerate for\n    the index of the black square in the row. In turn getting the absolute difference\n    between the index and the length of the row so we capture the index of the mirror\n    colours. We will then append the correct colour into a new list and finally\n    reshape it to the 3x3 array.\n    '''\n    # 1st we will create an empty list to append the correct pattern into\n    answer = []\n\n    # We will now get the shape of the array to determine the length of each row\n    h, w = x.shape\n\n    # We will now start the loop through the array\n    for i in x:\n\n        # We will set the value for the black square\n        black = 0\n\n        # We will enumerate to identify the length of each row that has a black square\n        non_count = [j for j, y in enumerate(i) if y != black]\n\n        # Now create an if statement to pass the row into the next loop if contains a\n        # black square\n        if len(non_count) != w:\n\n            # We will now enumerate to identify the count of the black squares\n            zero_index = [j for j, y in enumerate(i) if y == black]\n\n            # Create a (1,3) array of the maximum index number so we can calculate\n            # the mirror location of the black square\n            mirror_index = [w - 1] * max(zero_index)\n\n            # Create an empty list of the mirrored index number\n            index = []\n\n            # Create a loop to get the location of the black square and the mirror\n            # location by getting the absolute difference between the indexes\n            for q, p in zip(mirror_index, zero_index):\n                index.append(abs(q - p))\n\n            # Finally we will append the colour of the mirrored index in the row\n            for c in index:\n\n                # Append the colour to the def global answer\n                answer = np.append(answer, [i[c]], axis=0)\n\n    # We will now reshape the list to the correct array size\n    x = answer.reshape(3, -3)\n\n    return x\n\ndef solve_178fcbfb(x):\n    '''\n    ########################### SOLUTION No.6 ###############################\n    Using the ARC testing interface Task 178fcbfb shows a number of NxM arrays\n    where N is sometimes equal to M. There are 3 colours red, green and\n    blue in a number of squares in each array. The solution for each task shows\n    that the green and blue squares fill their row completely with their colour.\n    Then the the red is filled in vertically, under-lapping the green and blue\n    squares.\n\n\n    To solve the task we will enumerate the array and identify which rows contain\n    a black (zero) square by calculating the length of the row with a non-black. If\n    the row a non-black square, we will pass this into another loop to enumerate for\n    the value of the colour in the row. If not red (2) we will then enumerate the row\n    to replace all the black (0) squares in with its correct colour. After this we\n    will redo the above by transposing the array and look for the red (2) squares\n    only to replace the black (0) values with red.\n    '''\n    # First we need to get the shape of the array to sense check which rows need to\n    # be passed into the loop to fill out the colour in the row\n    h, w = x.shape\n\n    # Initiate loop through the array\n    for i in x:\n\n        # We will set the value for the black square\n        black = 0\n\n        # We will enumerate to identify the length of each row that has a black square\n        is_black = [j for j, y in enumerate(i) if y == black]\n\n        # Now create an if statement to pass the row into the next loop if contains a\n        # black square\n        if len(is_black) != w:\n\n            # We will now enumerate to identify the count of the black squares\n            non_black = [j for j, y in enumerate(i) if y != black]\n\n            # We will now store the colour value\n            colour = i[non_black]\n\n            # We will now sense check that this row does not contain red (2)\n            if colour != 2:\n\n                # We will now enumerate to identify the index of the black squares\n                zero_index = [j for j, y in enumerate(i) if y == black]\n\n                # We will now loop through to replace the black squares\n                for b in zero_index:\n\n                    # Replacing the values with the colour\n                    i[b] = colour\n\n    # Initiate loop through the transposed array\n    for i in x.T:\n\n        # We will set the value for the black square\n        black = 0\n\n        # We will enumerate to identify the length of each row that has a black square\n        is_black = [j for j, y in enumerate(i) if y == black]\n\n        # Now create an if statement to pass the row into the next loop if contains a\n        # black square\n        if len(is_black) != w:\n\n            # We will now enumerate to identify the count of the black squares\n            non_black = [j for j, y in enumerate(i) if y != black]\n\n            # We will now store the colour value\n            colour = i[non_black]\n\n            # We will need to only pass in the row with the red (2) value\n            if 2 in colour:\n\n                # We will now enumerate to identify the count of the black squares\n                zero_index = [j for j, y in enumerate(i) if y == black]\n\n                # We will now loop through to replace the black squares\n                for b in zero_index:\n\n                    # Replacing the values with the red (2)\n                    i[b] = 2\n    return x\n\n\ndef main():\n    # Find all the functions defined in this file whose names are\n    # like solve_abcd1234(), and run them.\n\n    # regex to match solve_* functions and extract task IDs\n    p = r\"solve_([a-f0-9]{8})\" \n    tasks_solvers = []\n    # globals() gives a dict containing all global names (variables\n    # and functions), as name: value pairs.\n    for name in globals(): \n        m = re.match(p, name)\n        if m:\n            # if the name fits the pattern eg solve_abcd1234\n            ID = m.group(1) # just the task ID\n            solve_fn = globals()[name] # the fn itself\n            tasks_solvers.append((ID, solve_fn))\n\n    for ID, solve_fn in tasks_solvers:\n        # for each task, read the data and call test()\n        directory = os.path.join(\"..\", \"data\", \"training\")\n        json_filename = os.path.join(directory, ID + \".json\")\n        data = read_ARC_JSON(json_filename)\n        test(ID, solve_fn, data)\n    \ndef read_ARC_JSON(filepath):\n    \"\"\"Given a filepath, read in the ARC task data which is in JSON\n    format. Extract the train/test input/output pairs of\n    grids. Convert each grid to np.array and return train_input,\n    train_output, test_input, test_output.\"\"\"\n    \n    # Open the JSON file and load it \n    data = json.load(open(filepath))\n\n    # Extract the train/test input/output grids. Each grid will be a\n    # list of lists of ints. We convert to Numpy.\n    train_input = [np.array(data['train'][i]['input']) for i in range(len(data['train']))]\n    train_output = [np.array(data['train'][i]['output']) for i in range(len(data['train']))]\n    test_input = [np.array(data['test'][i]['input']) for i in range(len(data['test']))]\n    test_output = [np.array(data['test'][i]['output']) for i in range(len(data['test']))]\n\n    return (train_input, train_output, test_input, test_output)\n\n\ndef test(taskID, solve, data):\n    \"\"\"Given a task ID, call the given solve() function on every\n    example in the task data.\"\"\"\n    print(taskID)\n    train_input, train_output, test_input, test_output = data\n    print(\"Training grids\")\n    for x, y in zip(train_input, train_output):\n        yhat = solve(x)\n        show_result(x, y, yhat)\n    print(\"Test grids\")\n    for x, y in zip(test_input, test_output):\n        yhat = solve(x)\n        show_result(x, y, yhat)\n\n        \ndef show_result(x, y, yhat):\n    print(\"Input\")\n    print(x)\n    print(\"Correct output\")\n    print(y)\n    print(\"Our output\")\n    print(yhat)\n    print(\"Correct?\")\n    if y.shape != yhat.shape:\n        print(f\"False. Incorrect shape: {y.shape} v {yhat.shape}\")\n    else:\n        print(np.all(y == yhat))\n\n\nif __name__ == \"__main__\": main()\n\n", "meta": {"hexsha": "ce02e8c7c4ebfc0268971b955bfd53aee57da916", "size": 20868, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/manual_solve.py", "max_stars_repo_name": "john9d/ARC", "max_stars_repo_head_hexsha": "86a284f22c220c6807f06f8187891c3ef06fab0d", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/manual_solve.py", "max_issues_repo_name": "john9d/ARC", "max_issues_repo_head_hexsha": "86a284f22c220c6807f06f8187891c3ef06fab0d", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/manual_solve.py", "max_forks_repo_name": "john9d/ARC", "max_forks_repo_head_hexsha": "86a284f22c220c6807f06f8187891c3ef06fab0d", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.7485714286, "max_line_length": 92, "alphanum_fraction": 0.6478819245, "include": true, "reason": "import numpy", "num_tokens": 5101, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4921881357207955, "lm_q2_score": 0.1384617905689644, "lm_q1q2_score": 0.06814925056870182}}
{"text": "\"\"\"Module for compiling codegen output, and wrap the binary for use in\npython.\n\n.. note:: To use the autowrap module it must first be imported\n\n   >>> from sympy.utilities.autowrap import autowrap\n\nThis module provides a common interface for different external backends, such\nas f2py, fwrap, Cython, SWIG(?) etc. (Currently only f2py and Cython are\nimplemented) The goal is to provide access to compiled binaries of acceptable\nperformance with a one-button user interface, i.e.\n\n    >>> from sympy.abc import x,y\n    >>> expr = ((x - y)**(25)).expand()\n    >>> binary_callable = autowrap(expr)\n    >>> binary_callable(1, 2)\n    -1.0\n\nThe callable returned from autowrap() is a binary python function, not a\nSymPy object.  If it is desired to use the compiled function in symbolic\nexpressions, it is better to use binary_function() which returns a SymPy\nFunction object.  The binary callable is attached as the _imp_ attribute and\ninvoked when a numerical evaluation is requested with evalf(), or with\nlambdify().\n\n    >>> from sympy.utilities.autowrap import binary_function\n    >>> f = binary_function('f', expr)\n    >>> 2*f(x, y) + y\n    y + 2*f(x, y)\n    >>> (2*f(x, y) + y).evalf(2, subs={x: 1, y:2})\n    0.e-110\n\nThe idea is that a SymPy user will primarily be interested in working with\nmathematical expressions, and should not have to learn details about wrapping\ntools in order to evaluate expressions numerically, even if they are\ncomputationally expensive.\n\nWhen is this useful?\n\n    1) For computations on large arrays, Python iterations may be too slow,\n       and depending on the mathematical expression, it may be difficult to\n       exploit the advanced index operations provided by NumPy.\n\n    2) For *really* long expressions that will be called repeatedly, the\n       compiled binary should be significantly faster than SymPy's .evalf()\n\n    3) If you are generating code with the codegen utility in order to use\n       it in another project, the automatic python wrappers let you test the\n       binaries immediately from within SymPy.\n\n    4) To create customized ufuncs for use with numpy arrays.\n       See *ufuncify*.\n\nWhen is this module NOT the best approach?\n\n    1) If you are really concerned about speed or memory optimizations,\n       you will probably get better results by working directly with the\n       wrapper tools and the low level code.  However, the files generated\n       by this utility may provide a useful starting point and reference\n       code. Temporary files will be left intact if you supply the keyword\n       tempdir=\"path/to/files/\".\n\n    2) If the array computation can be handled easily by numpy, and you\n       don't need the binaries for another project.\n\n\"\"\"\n\nfrom __future__ import print_function, division\n\nimport sys\nimport os\nimport shutil\nimport tempfile\nfrom subprocess import STDOUT, CalledProcessError, check_output\nfrom string import Template\nfrom warnings import warn\n\nfrom sympy.core.cache import cacheit\nfrom sympy.core.compatibility import range, iterable\nfrom sympy.core.function import Lambda\nfrom sympy.core.relational import Eq\nfrom sympy.core.symbol import Dummy, Symbol\nfrom sympy.tensor.indexed import Idx, IndexedBase\nfrom sympy.utilities.codegen import (make_routine, get_code_generator,\n                                     OutputArgument, InOutArgument,\n                                     InputArgument, CodeGenArgumentListError,\n                                     Result, ResultBase, C99CodeGen)\nfrom sympy.utilities.lambdify import implemented_function\nfrom sympy.utilities.decorator import doctest_depends_on\n\n_doctest_depends_on = {'exe': ('f2py', 'gfortran', 'gcc'),\n                       'modules': ('numpy',)}\n\n\nclass CodeWrapError(Exception):\n    pass\n\n\nclass CodeWrapper(object):\n    \"\"\"Base Class for code wrappers\"\"\"\n    _filename = \"wrapped_code\"\n    _module_basename = \"wrapper_module\"\n    _module_counter = 0\n\n    @property\n    def filename(self):\n        return \"%s_%s\" % (self._filename, CodeWrapper._module_counter)\n\n    @property\n    def module_name(self):\n        return \"%s_%s\" % (self._module_basename, CodeWrapper._module_counter)\n\n    def __init__(self, generator, filepath=None, flags=[], verbose=False):\n        \"\"\"\n        generator -- the code generator to use\n        \"\"\"\n        self.generator = generator\n        self.filepath = filepath\n        self.flags = flags\n        self.quiet = not verbose\n\n    @property\n    def include_header(self):\n        return bool(self.filepath)\n\n    @property\n    def include_empty(self):\n        return bool(self.filepath)\n\n    def _generate_code(self, main_routine, routines):\n        routines.append(main_routine)\n        self.generator.write(\n            routines, self.filename, True, self.include_header,\n            self.include_empty)\n\n    def wrap_code(self, routine, helpers=[]):\n\n        workdir = self.filepath or tempfile.mkdtemp(\"_sympy_compile\")\n        if not os.access(workdir, os.F_OK):\n            os.mkdir(workdir)\n        oldwork = os.getcwd()\n        os.chdir(workdir)\n        try:\n            sys.path.append(workdir)\n            self._generate_code(routine, helpers)\n            self._prepare_files(routine)\n            self._process_files(routine)\n            mod = __import__(self.module_name)\n        finally:\n            sys.path.remove(workdir)\n            CodeWrapper._module_counter += 1\n            os.chdir(oldwork)\n            if not self.filepath:\n                try:\n                    shutil.rmtree(workdir)\n                except OSError:\n                    # Could be some issues on Windows\n                    pass\n\n        return self._get_wrapped_function(mod, routine.name)\n\n    def _process_files(self, routine):\n        command = self.command\n        command.extend(self.flags)\n        try:\n            retoutput = check_output(command, stderr=STDOUT)\n        except CalledProcessError as e:\n            raise CodeWrapError(\n                \"Error while executing command: %s. Command output is:\\n%s\" % (\n                    \" \".join(command), e.output.decode()))\n        if not self.quiet:\n            print(retoutput)\n\n\nclass DummyWrapper(CodeWrapper):\n    \"\"\"Class used for testing independent of backends \"\"\"\n\n    template = \"\"\"# dummy module for testing of SymPy\ndef %(name)s():\n    return \"%(expr)s\"\n%(name)s.args = \"%(args)s\"\n%(name)s.returns = \"%(retvals)s\"\n\"\"\"\n\n    def _prepare_files(self, routine):\n        return\n\n    def _generate_code(self, routine, helpers):\n        with open('%s.py' % self.module_name, 'w') as f:\n            printed = \", \".join(\n                [str(res.expr) for res in routine.result_variables])\n            # convert OutputArguments to return value like f2py\n            args = filter(lambda x: not isinstance(\n                x, OutputArgument), routine.arguments)\n            retvals = []\n            for val in routine.result_variables:\n                if isinstance(val, Result):\n                    retvals.append('nameless')\n                else:\n                    retvals.append(val.result_var)\n\n            print(DummyWrapper.template % {\n                'name': routine.name,\n                'expr': printed,\n                'args': \", \".join([str(a.name) for a in args]),\n                'retvals': \", \".join([str(val) for val in retvals])\n            }, end=\"\", file=f)\n\n    def _process_files(self, routine):\n        return\n\n    @classmethod\n    def _get_wrapped_function(cls, mod, name):\n        return getattr(mod, name)\n\n\nclass CythonCodeWrapper(CodeWrapper):\n    \"\"\"Wrapper that uses Cython\"\"\"\n\n    setup_template = \"\"\"\\\ntry:\n    from setuptools import setup\n    from setuptools import Extension\nexcept ImportError:\n    from distutils.core import setup\n    from distutils.extension import Extension\nfrom Cython.Build import cythonize\ncy_opts = {cythonize_options}\n{np_import}\next_mods = [Extension(\n    {ext_args},\n    include_dirs={include_dirs},\n    library_dirs={library_dirs},\n    libraries={libraries},\n    extra_compile_args={extra_compile_args},\n    extra_link_args={extra_link_args}\n)]\nsetup(ext_modules=cythonize(ext_mods, **cy_opts))\n\"\"\"\n\n    pyx_imports = (\n        \"import numpy as np\\n\"\n        \"cimport numpy as np\\n\\n\")\n\n    pyx_header = (\n        \"cdef extern from '{header_file}.h':\\n\"\n        \"    {prototype}\\n\\n\")\n\n    pyx_func = (\n        \"def {name}_c({arg_string}):\\n\"\n        \"\\n\"\n        \"{declarations}\"\n        \"{body}\")\n\n    std_compile_flag = '-std=c99'\n\n    def __init__(self, *args, **kwargs):\n        \"\"\"Instantiates a Cython code wrapper.\n\n        The following optional parameters get passed to ``distutils.Extension``\n        for building the Python extension module. Read its documentation to\n        learn more.\n\n        Parameters\n        ==========\n        include_dirs : [list of strings]\n            A list of directories to search for C/C++ header files (in Unix\n            form for portability).\n        library_dirs : [list of strings]\n            A list of directories to search for C/C++ libraries at link time.\n        libraries : [list of strings]\n            A list of library names (not filenames or paths) to link against.\n        extra_compile_args : [list of strings]\n            Any extra platform- and compiler-specific information to use when\n            compiling the source files in 'sources'.  For platforms and\n            compilers where \"command line\" makes sense, this is typically a\n            list of command-line arguments, but for other platforms it could be\n            anything. Note that the attribute ``std_compile_flag`` will be\n            appended to this list.\n        extra_link_args : [list of strings]\n            Any extra platform- and compiler-specific information to use when\n            linking object files together to create the extension (or to create\n            a new static Python interpreter). Similar interpretation as for\n            'extra_compile_args'.\n        cythonize_options : [dictionary]\n            Keyword arguments passed on to cythonize.\n\n        \"\"\"\n\n        self._include_dirs = kwargs.pop('include_dirs', [])\n        self._library_dirs = kwargs.pop('library_dirs', [])\n        self._libraries = kwargs.pop('libraries', [])\n        self._extra_compile_args = kwargs.pop('extra_compile_args', [])\n        self._extra_compile_args.append(self.std_compile_flag)\n        self._extra_link_args = kwargs.pop('extra_link_args', [])\n        self._cythonize_options = kwargs.pop('cythonize_options', {})\n\n        self._need_numpy = False\n\n        super(CythonCodeWrapper, self).__init__(*args, **kwargs)\n\n    @property\n    def command(self):\n        command = [sys.executable, \"setup.py\", \"build_ext\", \"--inplace\"]\n        return command\n\n    def _prepare_files(self, routine, build_dir=os.curdir):\n        # NOTE : build_dir is used for testing purposes.\n        pyxfilename = self.module_name + '.pyx'\n        codefilename = \"%s.%s\" % (self.filename, self.generator.code_extension)\n\n        # pyx\n        with open(pyxfilename, 'w') as f:\n            self.dump_pyx([routine], f, self.filename)\n\n        # setup.py\n        ext_args = [repr(self.module_name), repr([pyxfilename, codefilename])]\n        if self._need_numpy:\n            np_import = 'import numpy as np\\n'\n            self._include_dirs.append('np.get_include()')\n        else:\n            np_import = ''\n\n        with open(os.path.join(build_dir, 'setup.py'), 'w') as f:\n            includes = str(self._include_dirs).replace(\"'np.get_include()'\",\n                                                       'np.get_include()')\n            f.write(self.setup_template.format(\n                ext_args=\", \".join(ext_args),\n                np_import=np_import,\n                include_dirs=includes,\n                library_dirs=self._library_dirs,\n                libraries=self._libraries,\n                extra_compile_args=self._extra_compile_args,\n                extra_link_args=self._extra_link_args,\n                cythonize_options=self._cythonize_options\n            ))\n\n    @classmethod\n    def _get_wrapped_function(cls, mod, name):\n        return getattr(mod, name + '_c')\n\n    def dump_pyx(self, routines, f, prefix):\n        \"\"\"Write a Cython file with python wrappers\n\n        This file contains all the definitions of the routines in c code and\n        refers to the header file.\n\n        Arguments\n        ---------\n        routines\n            List of Routine instances\n        f\n            File-like object to write the file to\n        prefix\n            The filename prefix, used to refer to the proper header file.\n            Only the basename of the prefix is used.\n        \"\"\"\n        headers = []\n        functions = []\n        for routine in routines:\n            prototype = self.generator.get_prototype(routine)\n\n            # C Function Header Import\n            headers.append(self.pyx_header.format(header_file=prefix,\n                                                  prototype=prototype))\n\n            # Partition the C function arguments into categories\n            py_rets, py_args, py_loc, py_inf = self._partition_args(routine.arguments)\n\n            # Function prototype\n            name = routine.name\n            arg_string = \", \".join(self._prototype_arg(arg) for arg in py_args)\n\n            # Local Declarations\n            local_decs = []\n            for arg, val in py_inf.items():\n                proto = self._prototype_arg(arg)\n                mat, ind = val\n                local_decs.append(\"    cdef {0} = {1}.shape[{2}]\".format(proto, mat, ind))\n            local_decs.extend([\"    cdef {0}\".format(self._declare_arg(a)) for a in py_loc])\n            declarations = \"\\n\".join(local_decs)\n            if declarations:\n                declarations = declarations + \"\\n\"\n\n            # Function Body\n            args_c = \", \".join([self._call_arg(a) for a in routine.arguments])\n            rets = \", \".join([str(r.name) for r in py_rets])\n            if routine.results:\n                body = '    return %s(%s)' % (routine.name, args_c)\n                if rets:\n                    body = body + ', ' + rets\n            else:\n                body = '    %s(%s)\\n' % (routine.name, args_c)\n                body = body + '    return ' + rets\n\n            functions.append(self.pyx_func.format(name=name, arg_string=arg_string,\n                    declarations=declarations, body=body))\n\n        # Write text to file\n        if self._need_numpy:\n            # Only import numpy if required\n            f.write(self.pyx_imports)\n        f.write('\\n'.join(headers))\n        f.write('\\n'.join(functions))\n\n    def _partition_args(self, args):\n        \"\"\"Group function arguments into categories.\"\"\"\n        py_args = []\n        py_returns = []\n        py_locals = []\n        py_inferred = {}\n        for arg in args:\n            if isinstance(arg, OutputArgument):\n                py_returns.append(arg)\n                py_locals.append(arg)\n            elif isinstance(arg, InOutArgument):\n                py_returns.append(arg)\n                py_args.append(arg)\n            else:\n                py_args.append(arg)\n        # Find arguments that are array dimensions. These can be inferred\n        # locally in the Cython code.\n            if isinstance(arg, (InputArgument, InOutArgument)) and arg.dimensions:\n                dims = [d[1] + 1 for d in arg.dimensions]\n                sym_dims = [(i, d) for (i, d) in enumerate(dims) if\n                            isinstance(d, Symbol)]\n                for (i, d) in sym_dims:\n                    py_inferred[d] = (arg.name, i)\n        for arg in args:\n            if arg.name in py_inferred:\n                py_inferred[arg] = py_inferred.pop(arg.name)\n        # Filter inferred arguments from py_args\n        py_args = [a for a in py_args if a not in py_inferred]\n        return py_returns, py_args, py_locals, py_inferred\n\n    def _prototype_arg(self, arg):\n        mat_dec = \"np.ndarray[{mtype}, ndim={ndim}] {name}\"\n        np_types = {'double': 'np.double_t',\n                    'int': 'np.int_t'}\n        t = arg.get_datatype('c')\n        if arg.dimensions:\n            self._need_numpy = True\n            ndim = len(arg.dimensions)\n            mtype = np_types[t]\n            return mat_dec.format(mtype=mtype, ndim=ndim, name=arg.name)\n        else:\n            return \"%s %s\" % (t, str(arg.name))\n\n    def _declare_arg(self, arg):\n        proto = self._prototype_arg(arg)\n        if arg.dimensions:\n            shape = '(' + ','.join(str(i[1] + 1) for i in arg.dimensions) + ')'\n            return proto + \" = np.empty({shape})\".format(shape=shape)\n        else:\n            return proto + \" = 0\"\n\n    def _call_arg(self, arg):\n        if arg.dimensions:\n            t = arg.get_datatype('c')\n            return \"<{0}*> {1}.data\".format(t, arg.name)\n        elif isinstance(arg, ResultBase):\n            return \"&{0}\".format(arg.name)\n        else:\n            return str(arg.name)\n\n\nclass F2PyCodeWrapper(CodeWrapper):\n    \"\"\"Wrapper that uses f2py\"\"\"\n\n    def __init__(self, *args, **kwargs):\n\n        ext_keys = ['include_dirs', 'library_dirs', 'libraries',\n                    'extra_compile_args', 'extra_link_args']\n        msg = ('The compilation option kwarg {} is not supported with the f2py '\n               'backend.')\n\n        for k in ext_keys:\n            if k in kwargs.keys():\n                warn(msg.format(k))\n            kwargs.pop(k, None)\n\n        super(F2PyCodeWrapper, self).__init__(*args, **kwargs)\n\n    @property\n    def command(self):\n        filename = self.filename + '.' + self.generator.code_extension\n        args = ['-c', '-m', self.module_name, filename]\n        command = [sys.executable, \"-c\", \"import numpy.f2py as f2py2e;f2py2e.main()\"]+args\n        return command\n\n    def _prepare_files(self, routine):\n        pass\n\n    @classmethod\n    def _get_wrapped_function(cls, mod, name):\n        return getattr(mod, name)\n\n\n# Here we define a lookup of backends -> tuples of languages. For now, each\n# tuple is of length 1, but if a backend supports more than one language,\n# the most preferable language is listed first.\n_lang_lookup = {'CYTHON': ('C99', 'C89', 'C'),\n                'F2PY': ('F95',),\n                'NUMPY': ('C99', 'C89', 'C'),\n                'DUMMY': ('F95',)}     # Dummy here just for testing\n\n\ndef _infer_language(backend):\n    \"\"\"For a given backend, return the top choice of language\"\"\"\n    langs = _lang_lookup.get(backend.upper(), False)\n    if not langs:\n        raise ValueError(\"Unrecognized backend: \" + backend)\n    return langs[0]\n\n\ndef _validate_backend_language(backend, language):\n    \"\"\"Throws error if backend and language are incompatible\"\"\"\n    langs = _lang_lookup.get(backend.upper(), False)\n    if not langs:\n        raise ValueError(\"Unrecognized backend: \" + backend)\n    if language.upper() not in langs:\n        raise ValueError((\"Backend {0} and language {1} are \"\n                          \"incompatible\").format(backend, language))\n\n\n@cacheit\n@doctest_depends_on(exe=('f2py', 'gfortran'), modules=('numpy',))\ndef autowrap(expr, language=None, backend='f2py', tempdir=None, args=None,\n             flags=None, verbose=False, helpers=None, code_gen=None, **kwargs):\n    \"\"\"Generates python callable binaries based on the math expression.\n\n    Parameters\n    ----------\n    expr\n        The SymPy expression that should be wrapped as a binary routine.\n    language : string, optional\n        If supplied, (options: 'C' or 'F95'), specifies the language of the\n        generated code. If ``None`` [default], the language is inferred based\n        upon the specified backend.\n    backend : string, optional\n        Backend used to wrap the generated code. Either 'f2py' [default],\n        or 'cython'.\n    tempdir : string, optional\n        Path to directory for temporary files. If this argument is supplied,\n        the generated code and the wrapper input files are left intact in the\n        specified path.\n    args : iterable, optional\n        An ordered iterable of symbols. Specifies the argument sequence for the\n        function.\n    flags : iterable, optional\n        Additional option flags that will be passed to the backend.\n    verbose : bool, optional\n        If True, autowrap will not mute the command line backends. This can be\n        helpful for debugging.\n    helpers : iterable, optional\n        Used to define auxillary expressions needed for the main expr. If the\n        main expression needs to call a specialized function it should be put\n        in the ``helpers`` iterable. Autowrap will then make sure that the\n        compiled main expression can link to the helper routine. Items should\n        be tuples with (<funtion_name>, <sympy_expression>, <arguments>). It\n        is mandatory to supply an argument sequence to helper routines.\n    code_gen : CodeGen instance\n        An instance of a CodeGen subclass. Overrides ``language``.\n    include_dirs : [string]\n        A list of directories to search for C/C++ header files (in Unix form\n        for portability).\n    library_dirs : [string]\n        A list of directories to search for C/C++ libraries at link time.\n    libraries : [string]\n        A list of library names (not filenames or paths) to link against.\n    extra_compile_args : [string]\n        Any extra platform- and compiler-specific information to use when\n        compiling the source files in 'sources'.  For platforms and compilers\n        where \"command line\" makes sense, this is typically a list of\n        command-line arguments, but for other platforms it could be anything.\n    extra_link_args : [string]\n        Any extra platform- and compiler-specific information to use when\n        linking object files together to create the extension (or to create a\n        new static Python interpreter).  Similar interpretation as for\n        'extra_compile_args'.\n\n    Examples\n    --------\n    >>> from sympy.abc import x, y, z\n    >>> from sympy.utilities.autowrap import autowrap\n    >>> expr = ((x - y + z)**(13)).expand()\n    >>> binary_func = autowrap(expr)\n    >>> binary_func(1, 4, 2)\n    -1.0\n    \"\"\"\n    if language:\n        if not isinstance(language, type):\n            _validate_backend_language(backend, language)\n    else:\n        language = _infer_language(backend)\n\n    helpers = [helpers] if helpers else ()\n    args = list(args) if iterable(args, exclude=set) else args\n\n    if code_gen is None:\n        code_gen = get_code_generator(language, \"autowrap\")\n\n    CodeWrapperClass = {\n        'F2PY': F2PyCodeWrapper,\n        'CYTHON': CythonCodeWrapper,\n        'DUMMY': DummyWrapper\n    }[backend.upper()]\n    code_wrapper = CodeWrapperClass(code_gen, tempdir, flags if flags else (),\n                                    verbose, **kwargs)\n\n    helps = []\n    for name_h, expr_h, args_h in helpers:\n        helps.append(make_routine(name_h, expr_h, args_h))\n\n    for name_h, expr_h, args_h in helpers:\n        if expr.has(expr_h):\n            name_h = binary_function(name_h, expr_h, backend='dummy')\n            expr = expr.subs(expr_h, name_h(*args_h))\n    try:\n        routine = make_routine('autofunc', expr, args)\n    except CodeGenArgumentListError as e:\n        # if all missing arguments are for pure output, we simply attach them\n        # at the end and try again, because the wrappers will silently convert\n        # them to return values anyway.\n        new_args = []\n        for missing in e.missing_args:\n            if not isinstance(missing, OutputArgument):\n                raise\n            new_args.append(missing.name)\n        routine = make_routine('autofunc', expr, args + new_args)\n\n    return code_wrapper.wrap_code(routine, helpers=helps)\n\n\n@doctest_depends_on(exe=('f2py', 'gfortran'), modules=('numpy',))\ndef binary_function(symfunc, expr, **kwargs):\n    \"\"\"Returns a sympy function with expr as binary implementation\n\n    This is a convenience function that automates the steps needed to\n    autowrap the SymPy expression and attaching it to a Function object\n    with implemented_function().\n\n    Parameters\n    ----------\n    symfunc : sympy Function\n        The function to bind the callable to.\n    expr : sympy Expression\n        The expression used to generate the function.\n    kwargs : dict\n        Any kwargs accepted by autowrap.\n\n    Examples\n    --------\n    >>> from sympy.abc import x, y\n    >>> from sympy.utilities.autowrap import binary_function\n    >>> expr = ((x - y)**(25)).expand()\n    >>> f = binary_function('f', expr)\n    >>> type(f)\n    <class 'sympy.core.function.UndefinedFunction'>\n    >>> 2*f(x, y)\n    2*f(x, y)\n    >>> f(x, y).evalf(2, subs={x: 1, y: 2})\n    -1.0\n    \"\"\"\n    binary = autowrap(expr, **kwargs)\n    return implemented_function(symfunc, binary)\n\n#################################################################\n#                           UFUNCIFY                            #\n#################################################################\n\n_ufunc_top = Template(\"\"\"\\\n#include \"Python.h\"\n#include \"math.h\"\n#include \"numpy/ndarraytypes.h\"\n#include \"numpy/ufuncobject.h\"\n#include \"numpy/halffloat.h\"\n#include ${include_file}\n\nstatic PyMethodDef ${module}Methods[] = {\n        {NULL, NULL, 0, NULL}\n};\"\"\")\n\n_ufunc_outcalls = Template(\"*((double *)out${outnum}) = ${funcname}(${call_args});\")\n\n_ufunc_body = Template(\"\"\"\\\nstatic void ${funcname}_ufunc(char **args, npy_intp *dimensions, npy_intp* steps, void* data)\n{\n    npy_intp i;\n    npy_intp n = dimensions[0];\n    ${declare_args}\n    ${declare_steps}\n    for (i = 0; i < n; i++) {\n        ${outcalls}\n        ${step_increments}\n    }\n}\nPyUFuncGenericFunction ${funcname}_funcs[1] = {&${funcname}_ufunc};\nstatic char ${funcname}_types[${n_types}] = ${types}\nstatic void *${funcname}_data[1] = {NULL};\"\"\")\n\n_ufunc_bottom = Template(\"\"\"\\\n#if PY_VERSION_HEX >= 0x03000000\nstatic struct PyModuleDef moduledef = {\n    PyModuleDef_HEAD_INIT,\n    \"${module}\",\n    NULL,\n    -1,\n    ${module}Methods,\n    NULL,\n    NULL,\n    NULL,\n    NULL\n};\n\nPyMODINIT_FUNC PyInit_${module}(void)\n{\n    PyObject *m, *d;\n    ${function_creation}\n    m = PyModule_Create(&moduledef);\n    if (!m) {\n        return NULL;\n    }\n    import_array();\n    import_umath();\n    d = PyModule_GetDict(m);\n    ${ufunc_init}\n    return m;\n}\n#else\nPyMODINIT_FUNC init${module}(void)\n{\n    PyObject *m, *d;\n    ${function_creation}\n    m = Py_InitModule(\"${module}\", ${module}Methods);\n    if (m == NULL) {\n        return;\n    }\n    import_array();\n    import_umath();\n    d = PyModule_GetDict(m);\n    ${ufunc_init}\n}\n#endif\\\n\"\"\")\n\n_ufunc_init_form = Template(\"\"\"\\\nufunc${ind} = PyUFunc_FromFuncAndData(${funcname}_funcs, ${funcname}_data, ${funcname}_types, 1, ${n_in}, ${n_out},\n            PyUFunc_None, \"${module}\", ${docstring}, 0);\n    PyDict_SetItemString(d, \"${funcname}\", ufunc${ind});\n    Py_DECREF(ufunc${ind});\"\"\")\n\n_ufunc_setup = Template(\"\"\"\\\ndef configuration(parent_package='', top_path=None):\n    import numpy\n    from numpy.distutils.misc_util import Configuration\n\n    config = Configuration('',\n                           parent_package,\n                           top_path)\n    config.add_extension('${module}', sources=['${module}.c', '${filename}.c'])\n\n    return config\n\nif __name__ == \"__main__\":\n    from numpy.distutils.core import setup\n    setup(configuration=configuration)\"\"\")\n\n\nclass UfuncifyCodeWrapper(CodeWrapper):\n    \"\"\"Wrapper for Ufuncify\"\"\"\n\n    def __init__(self, *args, **kwargs):\n\n        ext_keys = ['include_dirs', 'library_dirs', 'libraries',\n                    'extra_compile_args', 'extra_link_args']\n        msg = ('The compilation option kwarg {} is not supported with the numpy'\n               ' backend.')\n\n        for k in ext_keys:\n            if k in kwargs.keys():\n                warn(msg.format(k))\n            kwargs.pop(k, None)\n\n        super(UfuncifyCodeWrapper, self).__init__(*args, **kwargs)\n\n    @property\n    def command(self):\n        command = [sys.executable, \"setup.py\", \"build_ext\", \"--inplace\"]\n        return command\n\n    def wrap_code(self, routines, helpers=None):\n        # This routine overrides CodeWrapper because we can't assume funcname == routines[0].name\n        # Therefore we have to break the CodeWrapper private API.\n        # There isn't an obvious way to extend multi-expr support to\n        # the other autowrap backends, so we limit this change to ufuncify.\n        helpers = helpers if helpers is not None else []\n        # We just need a consistent name\n        funcname = 'wrapped_' + str(id(routines) + id(helpers))\n\n        workdir = self.filepath or tempfile.mkdtemp(\"_sympy_compile\")\n        if not os.access(workdir, os.F_OK):\n            os.mkdir(workdir)\n        oldwork = os.getcwd()\n        os.chdir(workdir)\n        try:\n            sys.path.append(workdir)\n            self._generate_code(routines, helpers)\n            self._prepare_files(routines, funcname)\n            self._process_files(routines)\n            mod = __import__(self.module_name)\n        finally:\n            sys.path.remove(workdir)\n            CodeWrapper._module_counter += 1\n            os.chdir(oldwork)\n            if not self.filepath:\n                try:\n                    shutil.rmtree(workdir)\n                except OSError:\n                    # Could be some issues on Windows\n                    pass\n\n        return self._get_wrapped_function(mod, funcname)\n\n    def _generate_code(self, main_routines, helper_routines):\n        all_routines = main_routines + helper_routines\n        self.generator.write(\n            all_routines, self.filename, True, self.include_header,\n            self.include_empty)\n\n    def _prepare_files(self, routines, funcname):\n\n        # C\n        codefilename = self.module_name + '.c'\n        with open(codefilename, 'w') as f:\n            self.dump_c(routines, f, self.filename, funcname=funcname)\n\n        # setup.py\n        with open('setup.py', 'w') as f:\n            self.dump_setup(f)\n\n    @classmethod\n    def _get_wrapped_function(cls, mod, name):\n        return getattr(mod, name)\n\n    def dump_setup(self, f):\n        setup = _ufunc_setup.substitute(module=self.module_name,\n                                        filename=self.filename)\n        f.write(setup)\n\n    def dump_c(self, routines, f, prefix, funcname=None):\n        \"\"\"Write a C file with python wrappers\n\n        This file contains all the definitions of the routines in c code.\n\n        Arguments\n        ---------\n        routines\n            List of Routine instances\n        f\n            File-like object to write the file to\n        prefix\n            The filename prefix, used to name the imported module.\n        funcname\n            Name of the main function to be returned.\n        \"\"\"\n        if (funcname is None) and (len(routines) == 1):\n            funcname = routines[0].name\n        elif funcname is None:\n            msg = 'funcname must be specified for multiple output routines'\n            raise ValueError(msg)\n        functions = []\n        function_creation = []\n        ufunc_init = []\n        module = self.module_name\n        include_file = \"\\\"{0}.h\\\"\".format(prefix)\n        top = _ufunc_top.substitute(include_file=include_file, module=module)\n\n        name = funcname\n\n        # Partition the C function arguments into categories\n        # Here we assume all routines accept the same arguments\n        r_index = 0\n        py_in, _ = self._partition_args(routines[0].arguments)\n        n_in = len(py_in)\n        n_out = len(routines)\n\n        # Declare Args\n        form = \"char *{0}{1} = args[{2}];\"\n        arg_decs = [form.format('in', i, i) for i in range(n_in)]\n        arg_decs.extend([form.format('out', i, i+n_in) for i in range(n_out)])\n        declare_args = '\\n    '.join(arg_decs)\n\n        # Declare Steps\n        form = \"npy_intp {0}{1}_step = steps[{2}];\"\n        step_decs = [form.format('in', i, i) for i in range(n_in)]\n        step_decs.extend([form.format('out', i, i+n_in) for i in range(n_out)])\n        declare_steps = '\\n    '.join(step_decs)\n\n        # Call Args\n        form = \"*(double *)in{0}\"\n        call_args = ', '.join([form.format(a) for a in range(n_in)])\n\n        # Step Increments\n        form = \"{0}{1} += {0}{1}_step;\"\n        step_incs = [form.format('in', i) for i in range(n_in)]\n        step_incs.extend([form.format('out', i, i) for i in range(n_out)])\n        step_increments = '\\n        '.join(step_incs)\n\n        # Types\n        n_types = n_in + n_out\n        types = \"{\" + ', '.join([\"NPY_DOUBLE\"]*n_types) + \"};\"\n\n        # Docstring\n        docstring = '\"Created in SymPy with Ufuncify\"'\n\n        # Function Creation\n        function_creation.append(\"PyObject *ufunc{0};\".format(r_index))\n\n        # Ufunc initialization\n        init_form = _ufunc_init_form.substitute(module=module,\n                                                funcname=name,\n                                                docstring=docstring,\n                                                n_in=n_in, n_out=n_out,\n                                                ind=r_index)\n        ufunc_init.append(init_form)\n\n        outcalls = [_ufunc_outcalls.substitute(\n            outnum=i, call_args=call_args, funcname=routines[i].name) for i in\n            range(n_out)]\n\n        body = _ufunc_body.substitute(module=module, funcname=name,\n                                      declare_args=declare_args,\n                                      declare_steps=declare_steps,\n                                      call_args=call_args,\n                                      step_increments=step_increments,\n                                      n_types=n_types, types=types,\n                                      outcalls='\\n        '.join(outcalls))\n        functions.append(body)\n\n        body = '\\n\\n'.join(functions)\n        ufunc_init = '\\n    '.join(ufunc_init)\n        function_creation = '\\n    '.join(function_creation)\n        bottom = _ufunc_bottom.substitute(module=module,\n                                          ufunc_init=ufunc_init,\n                                          function_creation=function_creation)\n        text = [top, body, bottom]\n        f.write('\\n\\n'.join(text))\n\n    def _partition_args(self, args):\n        \"\"\"Group function arguments into categories.\"\"\"\n        py_in = []\n        py_out = []\n        for arg in args:\n            if isinstance(arg, OutputArgument):\n                py_out.append(arg)\n            elif isinstance(arg, InOutArgument):\n                raise ValueError(\"Ufuncify doesn't support InOutArguments\")\n            else:\n                py_in.append(arg)\n        return py_in, py_out\n\n\n@cacheit\n@doctest_depends_on(exe=('f2py', 'gfortran', 'gcc'), modules=('numpy',))\ndef ufuncify(args, expr, language=None, backend='numpy', tempdir=None,\n             flags=None, verbose=False, helpers=None, **kwargs):\n    \"\"\"Generates a binary function that supports broadcasting on numpy arrays.\n\n    Parameters\n    ----------\n    args : iterable\n        Either a Symbol or an iterable of symbols. Specifies the argument\n        sequence for the function.\n    expr\n        A SymPy expression that defines the element wise operation.\n    language : string, optional\n        If supplied, (options: 'C' or 'F95'), specifies the language of the\n        generated code. If ``None`` [default], the language is inferred based\n        upon the specified backend.\n    backend : string, optional\n        Backend used to wrap the generated code. Either 'numpy' [default],\n        'cython', or 'f2py'.\n    tempdir : string, optional\n        Path to directory for temporary files. If this argument is supplied,\n        the generated code and the wrapper input files are left intact in\n        the specified path.\n    flags : iterable, optional\n        Additional option flags that will be passed to the backend.\n    verbose : bool, optional\n        If True, autowrap will not mute the command line backends. This can\n        be helpful for debugging.\n    helpers : iterable, optional\n        Used to define auxillary expressions needed for the main expr. If\n        the main expression needs to call a specialized function it should\n        be put in the ``helpers`` iterable. Autowrap will then make sure\n        that the compiled main expression can link to the helper routine.\n        Items should be tuples with (<funtion_name>, <sympy_expression>,\n        <arguments>). It is mandatory to supply an argument sequence to\n        helper routines.\n    kwargs : dict\n        These kwargs will be passed to autowrap if the `f2py` or `cython`\n        backend is used and ignored if the `numpy` backend is used.\n\n    Note\n    ----\n    The default backend ('numpy') will create actual instances of\n    ``numpy.ufunc``. These support ndimensional broadcasting, and implicit type\n    conversion. Use of the other backends will result in a \"ufunc-like\"\n    function, which requires equal length 1-dimensional arrays for all\n    arguments, and will not perform any type conversions.\n\n    References\n    ----------\n    [1] http://docs.scipy.org/doc/numpy/reference/ufuncs.html\n\n    Examples\n    ========\n\n    >>> from sympy.utilities.autowrap import ufuncify\n    >>> from sympy.abc import x, y\n    >>> import numpy as np\n    >>> f = ufuncify((x, y), y + x**2)\n    >>> type(f)\n    <class 'numpy.ufunc'>\n    >>> f([1, 2, 3], 2)\n    array([  3.,   6.,  11.])\n    >>> f(np.arange(5), 3)\n    array([  3.,   4.,   7.,  12.,  19.])\n\n    For the 'f2py' and 'cython' backends, inputs are required to be equal length\n    1-dimensional arrays. The 'f2py' backend will perform type conversion, but\n    the Cython backend will error if the inputs are not of the expected type.\n\n    >>> f_fortran = ufuncify((x, y), y + x**2, backend='f2py')\n    >>> f_fortran(1, 2)\n    array([ 3.])\n    >>> f_fortran(np.array([1, 2, 3]), np.array([1.0, 2.0, 3.0]))\n    array([  2.,   6.,  12.])\n    >>> f_cython = ufuncify((x, y), y + x**2, backend='Cython')\n    >>> f_cython(1, 2)  # doctest: +ELLIPSIS\n    Traceback (most recent call last):\n      ...\n    TypeError: Argument '_x' has incorrect type (expected numpy.ndarray, got int)\n    >>> f_cython(np.array([1.0]), np.array([2.0]))\n    array([ 3.])\n    \"\"\"\n\n    if isinstance(args, Symbol):\n        args = (args,)\n    else:\n        args = tuple(args)\n\n    if language:\n        _validate_backend_language(backend, language)\n    else:\n        language = _infer_language(backend)\n\n    helpers = helpers if helpers else ()\n    flags = flags if flags else ()\n\n    if backend.upper() == 'NUMPY':\n        # maxargs is set by numpy compile-time constant NPY_MAXARGS\n        # If a future version of numpy modifies or removes this restriction\n        # this variable should be changed or removed\n        maxargs = 32\n        helps = []\n        for name, expr, args in helpers:\n            helps.append(make_routine(name, expr, args))\n        code_wrapper = UfuncifyCodeWrapper(C99CodeGen(\"ufuncify\"), tempdir,\n                                           flags, verbose)\n        if not isinstance(expr, (list, tuple)):\n            expr = [expr]\n        if len(expr) == 0:\n            raise ValueError('Expression iterable has zero length')\n        if (len(expr) + len(args)) > maxargs:\n            msg = ('Cannot create ufunc with more than {0} total arguments: '\n                   'got {1} in, {2} out')\n            raise ValueError(msg.format(maxargs, len(args), len(expr)))\n        routines = [make_routine('autofunc{}'.format(idx), exprx, args) for\n                    idx, exprx in enumerate(expr)]\n        return code_wrapper.wrap_code(routines, helpers=helps)\n    else:\n        # Dummies are used for all added expressions to prevent name clashes\n        # within the original expression.\n        y = IndexedBase(Dummy())\n        m = Dummy(integer=True)\n        i = Idx(Dummy(integer=True), m)\n        f = implemented_function(Dummy().name, Lambda(args, expr))\n        # For each of the args create an indexed version.\n        indexed_args = [IndexedBase(Dummy(str(a))) for a in args]\n        # Order the arguments (out, args, dim)\n        args = [y] + indexed_args + [m]\n        args_with_indices = [a[i] for a in indexed_args]\n        return autowrap(Eq(y[i], f(*args_with_indices)), language, backend,\n                        tempdir, args, flags, verbose, helpers, **kwargs)\n", "meta": {"hexsha": "6a72bc0ee15169c49f118497ca5867a5cc38b826", "size": 40243, "ext": "py", "lang": "Python", "max_stars_repo_path": "webserver/python2.7/site-packages/sympy/utilities/autowrap.py", "max_stars_repo_name": "maxr1876/Radix", "max_stars_repo_head_hexsha": "bf9a5470908ea0823c8398565086b1e6b960c73b", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "webserver/python2.7/site-packages/sympy/utilities/autowrap.py", "max_issues_repo_name": "maxr1876/Radix", "max_issues_repo_head_hexsha": "bf9a5470908ea0823c8398565086b1e6b960c73b", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "webserver/python2.7/site-packages/sympy/utilities/autowrap.py", "max_forks_repo_name": "maxr1876/Radix", "max_forks_repo_head_hexsha": "bf9a5470908ea0823c8398565086b1e6b960c73b", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.6845943482, "max_line_length": 115, "alphanum_fraction": 0.6033098924, "include": true, "reason": "import numpy,from numpy,from sympy", "num_tokens": 9268, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4416730056646256, "lm_q2_score": 0.15405756269148543, "lm_q1q2_score": 0.06804306675931486}}
{"text": "# -*- coding: utf-8 -*-\nr\"\"\"\nCommon graphs\n\nAll graphs in Sage can be built through the ``graphs`` object. In order to\nbuild a complete graph on 15 elements, one can do::\n\n    sage: g = graphs.CompleteGraph(15)\n\nTo get a path with 4 vertices, and the house graph::\n\n    sage: p = graphs.PathGraph(4)\n    sage: h = graphs.HouseGraph()\n\nMore interestingly, one can get the list of all graphs that Sage knows how to\nbuild by typing ``graphs.`` in Sage and then hitting tab.\n\"\"\"\nfrom __future__ import print_function, absolute_import, division\nfrom sage.env import SAGE_NAUTY_BINS_PREFIX as nautyprefix\n\nimport subprocess\n\n# This method appends a list of methods to the doc as a 3xN table.\n\n# Here's the point :\n#\n# we just have to insert the method's name in this file to add it to\n# the tab, and in exchange the doc contains a table of width 3 with\n# all methods listed, so that the reading order is Column1, then\n# Column2, then Column3. Doing this by hand is hell with Sphinx when\n# you need to insert a new method inside of the list !\n\ndef __append_to_doc(methods):\n    global __doc__\n    __doc__ += (\"\\n.. csv-table::\\n\"\n    \"    :class: contentstable\\n\"\n    \"    :widths: 33, 33, 33\\n\"\n    \"    :delim: |\\n\\n\")\n\n    h = (len(methods)+2)//3\n    # Reorders the list of methods for horizontal reading, the only one Sphinx understands\n    reordered_methods = [0]*3*h\n    for i, m in enumerate(methods):\n        reordered_methods[3*(i%h)+(i//h)] = m\n    methods = reordered_methods\n\n    # Adding the list to the __doc__ string\n    wrap_name = lambda x : \":meth:`\"+str(x)+\" <GraphGenerators.\"+str(x)+\">`\" if x else \"\"\n    while methods:\n        a = methods.pop(0)\n        b = methods.pop(0)\n        c = methods.pop(0)\n        __doc__ += \"    \"+wrap_name(a)+\" | \"+wrap_name(b)+\" | \"+wrap_name(c)+\"\\n\"\n\n__doc__ += \"\"\"\n**Basic structures**\n\"\"\"\n\n__append_to_doc(\n    [\"BullGraph\",\n     \"ButterflyGraph\",\n     \"CircularLadderGraph\",\n     \"ClawGraph\",\n     \"CycleGraph\",\n     \"CompleteBipartiteGraph\",\n     \"CompleteGraph\",\n     \"CompleteMultipartiteGraph\",\n     \"DiamondGraph\",\n     \"GemGraph\",\n     \"DartGraph\",\n     \"ForkGraph\",\n     \"DipoleGraph\",\n     \"EmptyGraph\",\n     \"Grid2dGraph\",\n     \"GridGraph\",\n     \"HouseGraph\",\n     \"HouseXGraph\",\n     \"LadderGraph\",\n     \"LollipopGraph\",\n     \"PathGraph\",\n     \"StarGraph\",\n     \"TadpoleGraph\",\n     \"ToroidalGrid2dGraph\",\n     \"Toroidal6RegularGrid2dGraph\"]\n    )\n\n__doc__ += \"\"\"\n**Small Graphs**\n\nA small graph is just a single graph and has no parameter influencing\nthe number of edges or vertices.\n\"\"\"\n\n__append_to_doc(\n    [\"Balaban10Cage\",\n     \"Balaban11Cage\",\n     \"BidiakisCube\",\n     \"BiggsSmithGraph\",\n     \"BlanusaFirstSnarkGraph\",\n     \"BlanusaSecondSnarkGraph\",\n     \"BrinkmannGraph\",\n     \"BrouwerHaemersGraph\",\n     \"BuckyBall\",\n     \"CameronGraph\",\n     \"Cell600\",\n     \"Cell120\",\n     \"ChvatalGraph\",\n     \"ClebschGraph\",\n     \"cocliques_HoffmannSingleton\",\n     \"ConwaySmith_for_3S7\",\n     \"CoxeterGraph\",\n     \"DesarguesGraph\",\n     \"DejterGraph\",\n     \"distance_3_doubly_truncated_Golay_code_graph\",\n     \"DoubleStarSnark\",\n     \"DoublyTruncatedWittGraph\",\n     \"DurerGraph\",\n     \"DyckGraph\",\n     \"EllinghamHorton54Graph\",\n     \"EllinghamHorton78Graph\",\n     \"ErreraGraph\",\n     \"F26AGraph\",\n     \"FlowerSnark\",\n     \"FolkmanGraph\",\n     \"FosterGraph\",\n     \"FosterGraph3S6\",\n     \"FranklinGraph\",\n     \"FruchtGraph\",\n     \"GoldnerHararyGraph\",\n     \"GolombGraph\",\n     \"GossetGraph\",\n     \"graph_3O73\",\n     \"GrayGraph\",\n     \"GrotzschGraph\",\n     \"HallJankoGraph\",\n     \"HarborthGraph\",\n     \"HarriesGraph\",\n     \"HarriesWongGraph\",\n     \"HeawoodGraph\",\n     \"HerschelGraph\",\n     \"HigmanSimsGraph\",\n     \"HoffmanGraph\",\n     \"HoffmanSingletonGraph\",\n     \"HoltGraph\",\n     \"HortonGraph\",\n     \"IoninKharaghani765Graph\",\n     \"IvanovIvanovFaradjevGraph\",\n     \"J2Graph\",\n     \"JankoKharaghaniGraph\",\n     \"JankoKharaghaniTonchevGraph\",\n     \"KittellGraph\",\n     \"KrackhardtKiteGraph\",\n     \"Klein3RegularGraph\",\n     \"Klein7RegularGraph\",\n     \"LargeWittGraph\",\n     \"LeonardGraph\",\n     \"LjubljanaGraph\",\n     \"vanLintSchrijverGraph\",\n     \"LivingstoneGraph\",\n     \"locally_GQ42_distance_transitive_graph\",\n     \"LocalMcLaughlinGraph\",\n     \"M22Graph\",\n     \"MarkstroemGraph\",\n     \"MathonStronglyRegularGraph\",\n     \"McGeeGraph\",\n     \"McLaughlinGraph\",\n     \"MeredithGraph\",\n     \"MoebiusKantorGraph\",\n     \"MoserSpindle\",\n     \"NauruGraph\",\n     \"PappusGraph\",\n     \"PoussinGraph\",\n     \"PerkelGraph\",\n     \"PetersenGraph\",\n     \"RobertsonGraph\",\n     \"SchlaefliGraph\",\n     \"shortened_00_11_binary_Golay_code_graph\",\n     \"shortened_000_111_extended_binary_Golay_code_graph\",\n     \"ShrikhandeGraph\",\n     \"SimsGewirtzGraph\",\n     \"SousselierGraph\",\n     \"SylvesterGraph\",\n     \"SzekeresSnarkGraph\",\n     \"ThomsenGraph\",\n     \"TietzeGraph\",\n     \"TruncatedIcosidodecahedralGraph\",\n     \"TruncatedTetrahedralGraph\",\n     \"TruncatedWittGraph\",\n     \"Tutte12Cage\",\n     \"TutteCoxeterGraph\",\n     \"TutteGraph\",\n     \"U42Graph216\",\n     \"U42Graph540\",\n     \"WagnerGraph\",\n     \"WatkinsSnarkGraph\",\n     \"WellsGraph\",\n     \"WienerArayaGraph\",\n     \"SuzukiGraph\"])\n\n__doc__ += \"\"\"\n**Platonic solids** (ordered ascending by number of vertices)\n\"\"\"\n\n__append_to_doc(\n    [\"TetrahedralGraph\",\n     \"OctahedralGraph\",\n     \"HexahedralGraph\",\n     \"IcosahedralGraph\",\n     \"DodecahedralGraph\"])\n\n__doc__ += \"\"\"\n**Families of graphs**\n\nA family of graph is an infinite set of graphs which can be indexed by fixed\nnumber of parameters, e.g. two integer parameters. (A method whose name starts\nwith a small letter does not return a single graph object but a graph iterator\nor a list of graphs or ...)\n\"\"\"\n\n__append_to_doc(\n    [\"AlternatingFormsGraph\",\n     \"AztecDiamondGraph\",\n     \"BalancedTree\",\n     \"BarbellGraph\",\n     \"BilinearFormsGraph\",\n     \"BubbleSortGraph\",\n     \"CaiFurerImmermanGraph\",\n     \"chang_graphs\",\n     \"CirculantGraph\",\n     \"cospectral_graphs\",\n     \"CubeGraph\",\n     \"CubeConnectedCycle\",\n     \"DorogovtsevGoltsevMendesGraph\",\n     \"DoubleGrassmannGraph\",\n     \"DoubleOddGraph\",\n     \"EgawaGraph\",\n     \"FibonacciTree\",\n     \"FoldedCubeGraph\",\n     \"FriendshipGraph\",\n     \"fullerenes\",\n     \"FurerGadget\",\n     \"fusenes\",\n     \"FuzzyBallGraph\",\n     \"GeneralizedPetersenGraph\",\n     \"GoethalsSeidelGraph\",\n     \"GrassmannGraph\",\n     \"HalfCube\",\n     \"HammingGraph\",\n     \"HanoiTowerGraph\",\n     \"HararyGraph\",\n     \"HermitianFormsGraph\",\n     \"HyperStarGraph\",\n     \"JohnsonGraph\",\n     \"KneserGraph\",\n     \"LCFGraph\",\n     \"line_graph_forbidden_subgraphs\",\n     \"MathonPseudocyclicMergingGraph\",\n     \"MathonPseudocyclicStronglyRegularGraph\",\n     \"MuzychukS6Graph\",\n     \"MycielskiGraph\",\n     \"MycielskiStep\",\n     \"NKStarGraph\",\n     \"NStarGraph\",\n     \"OddGraph\",\n     \"PaleyGraph\",\n     \"PasechnikGraph\",\n     \"petersen_family\",\n     \"planar_graphs\",\n     \"quadrangulations\",\n     \"RingedTree\",\n     \"SierpinskiGasketGraph\",\n     \"SquaredSkewHadamardMatrixGraph\",\n     \"SwitchedSquaredSkewHadamardMatrixGraph\",\n     \"strongly_regular_graph\",\n     \"trees\",\n     \"triangulations\",\n     \"TuranGraph\",\n     \"UstimenkoGraph\",\n     \"WheelGraph\",\n     \"WindmillGraph\"])\n\n\n__doc__ += \"\"\"\n**Graphs from classical geometries over finite fields**\n\nA number of classes of graphs related to geometries over finite fields and\nquadrics and Hermitean varieties there.\n\"\"\"\n\n__append_to_doc(\n    [\"AffineOrthogonalPolarGraph\",\n     \"AhrensSzekeresGeneralizedQuadrangleGraph\",\n     \"NonisotropicOrthogonalPolarGraph\",\n     \"NonisotropicUnitaryPolarGraph\",\n     \"OrthogonalDualPolarGraph\",\n     \"OrthogonalPolarGraph\",\n     \"SymplecticDualPolarGraph\",\n     \"SymplecticPolarGraph\",\n     \"TaylorTwographDescendantSRG\",\n     \"TaylorTwographSRG\",\n     \"T2starGeneralizedQuadrangleGraph\",\n     \"Nowhere0WordsTwoWeightCodeGraph\",\n     \"HaemersGraph\",\n     \"CossidentePenttilaGraph\",\n     \"UnitaryDualPolarGraph\",\n     \"UnitaryPolarGraph\"])\n\n__doc__ += \"\"\"\n**Chessboard Graphs**\n\"\"\"\n\n__append_to_doc(\n    [\"BishopGraph\",\n     \"KingGraph\",\n     \"KnightGraph\",\n     \"QueenGraph\",\n     \"RookGraph\"])\n\n__doc__ += \"\"\"\n**Intersection graphs**\n\nThese graphs are generated by geometric representations. The objects of\nthe representation correspond to the graph vertices and the intersections\nof objects yield the graph edges.\n\"\"\"\n\n__append_to_doc(\n    [\"IntersectionGraph\",\n     \"IntervalGraph\",\n     \"OrthogonalArrayBlockGraph\",\n     \"PermutationGraph\",\n     \"ToleranceGraph\"])\n\n__doc__ += \"\"\"\n**Random graphs**\n\"\"\"\n\n__append_to_doc(\n    [\"RandomBarabasiAlbert\",\n     \"RandomBicubicPlanar\",\n     \"RandomBipartite\",\n     \"RandomRegularBipartite\",\n     \"RandomBlockGraph\",\n     \"RandomBoundedToleranceGraph\",\n     \"RandomGNM\",\n     \"RandomGNP\",\n     \"RandomHolmeKim\",\n     \"RandomChordalGraph\",\n     \"RandomIntervalGraph\",\n     \"RandomLobster\",\n     \"RandomNewmanWattsStrogatz\",\n     \"RandomRegular\",\n     \"RandomShell\",\n     \"RandomToleranceGraph\",\n     \"RandomTree\",\n     \"RandomTreePowerlaw\",\n     \"RandomTriangulation\"])\n\n__doc__ += \"\"\"\n**Graphs with a given degree sequence**\n\"\"\"\n\n__append_to_doc(\n    [\"DegreeSequence\",\n     \"DegreeSequenceBipartite\",\n     \"DegreeSequenceConfigurationModel\",\n     \"DegreeSequenceExpected\",\n     \"DegreeSequenceTree\"])\n\n__doc__ += \"\"\"\n**Miscellaneous**\n\"\"\"\n\n__append_to_doc(\n    [\"WorldMap\",\n     \"EuropeMap\",\n     \"AfricaMap\",\n     \"USAMap\"]\n    )\n\n__doc__ += \"\"\"\n\nAUTHORS:\n\n- Robert Miller (2006-11-05): initial version, empty, random, petersen\n\n- Emily Kirkman (2006-11-12): basic structures, node positioning for\n  all constructors\n\n- Emily Kirkman (2006-11-19): docstrings, examples\n\n- William Stein (2006-12-05): Editing.\n\n- Robert Miller (2007-01-16): Cube generation and plotting\n\n- Emily Kirkman (2007-01-16): more basic structures, docstrings\n\n- Emily Kirkman (2007-02-14): added more named graphs\n\n- Robert Miller (2007-06-08-11): Platonic solids, random graphs,\n  graphs with a given degree sequence, random directed graphs\n\n- Robert Miller (2007-10-24): Isomorph free exhaustive generation\n\n- Nathann Cohen (2009-08-12): WorldMap\n\n- Michael Yurko (2009-9-01): added hyperstar, (n,k)-star, n-star, and\n  bubblesort graphs\n\n- Anders Jonsson (2009-10-15): added generalized Petersen graphs\n\n- Harald Schilly and Yann Laigle-Chapuy (2010-03-24): added Fibonacci Tree\n\n- Jason Grout (2010-06-04): cospectral_graphs\n\n- Edward Scheinerman (2010-08-11): RandomTree\n\n- Ed Scheinerman (2010-08-21): added Grotzsch graph and Mycielski graphs\n\n- Ed Scheinerman (2010-11-15): added RandomTriangulation\n\n- Minh Van Nguyen (2010-11-26): added more named graphs\n\n- Keshav Kini (2011-02-16): added Shrikhande and Dyck graphs\n\n- David Coudert (2012-02-10): new RandomGNP generator\n\n- David Coudert (2012-08-02): added chessboard graphs: Queen, King,\n  Knight, Bishop, and Rook graphs\n\n- Nico Van Cleemput (2013-05-26): added fullerenes\n\n- Nico Van Cleemput (2013-07-01): added benzenoids\n\n- Birk Eisermann (2013-07-29): new section 'intersection graphs',\n  added (random, bounded) tolerance graphs\n\n- Marco Cognetta (2016-03-03): added TuranGraph\n\n\nFunctions and methods\n---------------------\n\"\"\"\n\n###########################################################################\n\n#           Copyright (C) 2006 Robert L. Miller <rlmillster@gmail.com>\n#                              and Emily A. Kirkman\n#           Copyright (C) 2009 Michael C. Yurko <myurko@gmail.com>\n#\n# Distributed  under  the  terms  of  the  GNU  General  Public  License (GPL)\n#                         http://www.gnu.org/licenses/\n###########################################################################\n\n# import from Python standard library\n\n# import from Sage library\nfrom . import graph\n\n\nclass GraphGenerators():\n    r\"\"\"\n    A class consisting of constructors for several common graphs, as well as\n    orderly generation of isomorphism class representatives. See the\n    :mod:`module's help <sage.graphs.graph_generators>` for a list of supported\n    constructors.\n\n    A list of all graphs and graph structures (other than isomorphism class\n    representatives) in this database is available via tab completion. Type\n    \"graphs.\" and then hit the tab key to see which graphs are available.\n\n    The docstrings include educational information about each named\n    graph with the hopes that this class can be used as a reference.\n\n    For all the constructors in this class (except the octahedral,\n    dodecahedral, random and empty graphs), the position dictionary is\n    filled to override the spring-layout algorithm.\n\n\n    ORDERLY GENERATION::\n\n        graphs(vertices, property=lambda x: True, augment='edges', size=None)\n\n    This syntax accesses the generator of isomorphism class\n    representatives. Iterates over distinct, exhaustive\n    representatives.\n\n    Also: see the use of the nauty package for generating graphs\n    at the :meth:`nauty_geng` method.\n\n    INPUT:\n\n    - ``vertices`` -- a natural number or ``None`` to infinitely generate\n      bigger and bigger graphs.\n\n    - ``property`` -- (default: ``lambda x: True``) any property to be\n      tested on graphs before generation, but note that in general the\n      graphs produced are not the same as those produced by using the\n      property function to filter a list of graphs produced by using\n      the ``lambda x: True`` default. The generation process assumes\n      the property has certain characteristics set by the ``augment``\n      argument, and only in the case of inherited properties such that\n      all subgraphs of the relevant kind (for ``augment='edges'`` or\n      ``augment='vertices'``) of a graph with the property also\n      possess the property will there be no missing graphs.  (The\n      ``property`` argument is ignored if ``degree_sequence`` is\n      specified.)\n\n    - ``augment`` -- (default: ``'edges'``) possible values:\n\n      - ``'edges'`` -- augments a fixed number of vertices by\n        adding one edge. In this case, all graphs on *exactly* ``n=vertices`` are\n        generated. If for any graph G satisfying the property, every\n        subgraph, obtained from G by deleting one edge but not the vertices\n        incident to that edge, satisfies the property, then this will\n        generate all graphs with that property. If this does not hold, then\n        all the graphs generated will satisfy the property, but there will\n        be some missing.\n\n      - ``'vertices'`` -- augments by adding a vertex and\n        edges incident to that vertex. In this case, all graphs *up to*\n        ``n=vertices`` are generated. If for any graph G satisfying the\n        property, every subgraph, obtained from G by deleting one vertex\n        and only edges incident to that vertex, satisfies the property,\n        then this will generate all graphs with that property. If this does\n        not hold, then all the graphs generated will satisfy the property,\n        but there will be some missing.\n\n    - ``size`` -- (default: ``None``) the size of the graph to be generated.\n\n    - ``degree_sequence`` -- (default: ``None``) a sequence of non-negative integers,\n      or ``None``. If specified, the generated graphs will have these\n      integers for degrees. In this case, property and size are both\n      ignored.\n\n    - ``loops`` -- (default: ``False``) whether to allow loops in the graph\n      or not.\n\n    - ``sparse`` -- (default: ``True``); whether to use a sparse or dense data\n      structure. See the documentation of :class:`~sage.graphs.graph.Graph`.\n\n    - ``copy`` (boolean) -- If set to ``True`` (default)\n      this method makes copies of the graphs before returning\n      them. If set to ``False`` the method returns the graph it\n      is working on. The second alternative is faster, but modifying\n      any of the graph instances returned by the method may break\n      the function's behaviour, as it is using these graphs to\n      compute the next ones: only use ``copy = False`` when\n      you stick to *reading* the graphs returned.\n\n    EXAMPLES:\n\n    Print graphs on 3 or less vertices::\n\n        sage: for G in graphs(3, augment='vertices'):\n        ....:     print(G)\n        Graph on 0 vertices\n        Graph on 1 vertex\n        Graph on 2 vertices\n        Graph on 3 vertices\n        Graph on 3 vertices\n        Graph on 3 vertices\n        Graph on 2 vertices\n        Graph on 3 vertices\n\n    Print graphs on 3 vertices.\n\n    ::\n\n        sage: for G in graphs(3):\n        ....:    print(G)\n        Graph on 3 vertices\n        Graph on 3 vertices\n        Graph on 3 vertices\n        Graph on 3 vertices\n\n    Generate all graphs with 5 vertices and 4 edges.\n\n    ::\n\n        sage: L = graphs(5, size=4)\n        sage: len(list(L))\n        6\n\n    Generate all graphs with 5 vertices and up to 4 edges.\n\n    ::\n\n        sage: L = list(graphs(5, lambda G: G.size() <= 4))\n        sage: len(L)\n        14\n        sage: graphs_list.show_graphs(L) # long time\n\n    Generate all graphs with up to 5 vertices and up to 4 edges.\n\n    ::\n\n        sage: L = list(graphs(5, lambda G: G.size() <= 4, augment='vertices'))\n        sage: len(L)\n        31\n        sage: graphs_list.show_graphs(L)              # long time\n\n    Generate all graphs with degree at most 2, up to 6 vertices.\n\n    ::\n\n        sage: property = lambda G: ( max([G.degree(v) for v in G] + [0]) <= 2 )\n        sage: L = list(graphs(6, property, augment='vertices'))\n        sage: len(L)\n        45\n\n    Generate all bipartite graphs on up to 7 vertices: (see\n    :oeis:`A033995`)\n\n    ::\n\n        sage: L = list( graphs(7, lambda G: G.is_bipartite(), augment='vertices') )\n        sage: [len([g for g in L if g.order() == i]) for i in [1..7]]\n        [1, 2, 3, 7, 13, 35, 88]\n\n    Generate all bipartite graphs on exactly 7 vertices::\n\n        sage: L = list( graphs(7, lambda G: G.is_bipartite()) )\n        sage: len(L)\n        88\n\n    Generate all bipartite graphs on exactly 8 vertices::\n\n        sage: L = list( graphs(8, lambda G: G.is_bipartite()) ) # long time\n        sage: len(L)                                            # long time\n        303\n\n    Remember that the property argument does not behave as a filter,\n    except for appropriately inheritable properties::\n\n        sage: property = lambda G: G.is_vertex_transitive()\n        sage: len(list(graphs(4, property)))\n        1\n        sage: sum(1 for g in graphs(4) if property(g))\n        4\n\n        sage: property = lambda G: G.is_bipartite()\n        sage: len(list(graphs(4, property)))\n        7\n        sage: sum(1 for g in graphs(4) if property(g))\n        7\n\n    Generate graphs on the fly: (see :oeis:`A000088`)\n\n    ::\n\n        sage: for i in range(7):\n        ....:     print(len(list(graphs(i))))\n        1\n        1\n        2\n        4\n        11\n        34\n        156\n\n    Generate all simple graphs, allowing loops: (see :oeis:`A000666`)\n\n    ::\n\n        sage: L = list(graphs(5,augment='vertices',loops=True))               # long time\n        sage: for i in [0..5]:  # long time\n        ....:     print((i, len([g for g in L if g.order() == i]))) # long time\n        (0, 1)\n        (1, 2)\n        (2, 6)\n        (3, 20)\n        (4, 90)\n        (5, 544)\n\n    Generate all graphs with a specified degree sequence (see :oeis:`A002851`)::\n\n        sage: for i in [4,6,8]:  # long time (4s on sage.math, 2012)\n        ....:     print((i, len([g for g in graphs(i, degree_sequence=[3]*i) if g.is_connected()])))\n        (4, 1)\n        (6, 2)\n        (8, 5)\n        sage: for i in [4,6,8]:  # long time (7s on sage.math, 2012)\n        ....:     print((i, len([g for g in graphs(i, augment='vertices', degree_sequence=[3]*i) if g.is_connected()])))\n        (4, 1)\n        (6, 2)\n        (8, 5)\n\n    ::\n\n        sage: print((10, len([g for g in graphs(10,degree_sequence=[3]*10) if g.is_connected()]))) # not tested\n        (10, 19)\n\n    Make sure that the graphs are really independent and the generator\n    survives repeated vertex removal (:trac:`8458`)::\n\n        sage: for G in graphs(3):\n        ....:     G.delete_vertex(0)\n        ....:     print(G.order())\n        2\n        2\n        2\n        2\n\n    REFERENCE:\n\n    - Brendan D. McKay, Isomorph-Free Exhaustive generation.  *Journal\n      of Algorithms*, Volume 26, Issue 2, February 1998, pages 306-324.\n    \"\"\"\n\n###########################################################################\n#   Graph Iterators\n###########################################################################\n\n    def __call__(self, vertices=None, property=None, augment='edges',\n        size=None, degree_sequence=None, loops=False, sparse=True, copy = True):\n        \"\"\"\n        Accesses the generator of isomorphism class representatives.\n        Iterates over distinct, exhaustive representatives. See the docstring\n        of this class for full documentation.\n\n        EXAMPLES:\n\n        Print graphs on 3 or less vertices::\n\n            sage: for G in graphs(3, augment='vertices'):\n            ....:    print(G)\n            Graph on 0 vertices\n            Graph on 1 vertex\n            Graph on 2 vertices\n            Graph on 3 vertices\n            Graph on 3 vertices\n            Graph on 3 vertices\n            Graph on 2 vertices\n            Graph on 3 vertices\n\n        ::\n\n            sage: for g in graphs():\n            ....:    if g.num_verts() > 3: break\n            ....:    print(g)\n            Graph on 0 vertices\n            Graph on 1 vertex\n            Graph on 2 vertices\n            Graph on 2 vertices\n            Graph on 3 vertices\n            Graph on 3 vertices\n            Graph on 3 vertices\n            Graph on 3 vertices\n\n        For more examples, see the class level documentation, or type::\n\n            sage: graphs? # not tested\n\n        REFERENCE:\n\n        - Brendan D. McKay, Isomorph-Free Exhaustive generation.\n          Journal of Algorithms Volume 26, Issue 2, February 1998,\n          pages 306-324.\n        \"\"\"\n        # Use nauty for the basic case, as it is much faster.\n        if (vertices and property is None and size is None and\n            degree_sequence is None and not loops and augment == 'edges' and\n            sparse and copy):\n            for g in graphs.nauty_geng(vertices):\n                yield g\n            return\n\n        if property is None:\n            def property(x):\n                return True\n\n        from sage.graphs.all import Graph\n        from copy import copy as copyfun\n\n        if degree_sequence is not None:\n            if vertices is None:\n                raise NotImplementedError\n            if len(degree_sequence) != vertices or sum(degree_sequence)%2 or sum(degree_sequence) > vertices*(vertices-1):\n                raise ValueError(\"Invalid degree sequence.\")\n            degree_sequence = sorted(degree_sequence)\n            if augment == 'edges':\n                def property(x):\n                    D = sorted(x.degree())\n                    return all(degree_sequence[i] >= d for i, d in enumerate(D))\n                def extra_property(x):\n                    return degree_sequence == sorted(x.degree())\n            else:\n                def property(x):\n                    D = sorted(x.degree() + [0] * (vertices - x.num_verts()))\n                    return all(degree_sequence[i] >= d for i, d in enumerate(D))\n                def extra_property(x):\n                    if x.num_verts() != vertices:\n                        return False\n                    return degree_sequence == sorted(x.degree())\n        elif size is not None:\n            def extra_property(x):\n                return x.size() == size\n        else:\n            def extra_property(x):\n                return True\n\n        if augment == 'vertices':\n            if vertices is None:\n                raise NotImplementedError\n            g = Graph(loops=loops, sparse=sparse)\n            for gg in canaug_traverse_vert(g, [], vertices, property, loops=loops, sparse=sparse):\n                if extra_property(gg):\n                    yield copyfun(gg) if copy else gg\n        elif augment == 'edges':\n            if vertices is None:\n                from sage.rings.all import Integer\n                vertices = Integer(0)\n                while True:\n                    for g in self(vertices, loops=loops, sparse=sparse):\n                        yield copyfun(g) if copy else g\n                    vertices += 1\n            g = Graph(vertices, loops=loops, sparse=sparse)\n            gens = []\n            for i in range(vertices-1):\n                gen = list(range(i))\n                gen.append(i+1)\n                gen.append(i)\n                gen += list(range(i + 2, vertices))\n                gens.append(gen)\n            for gg in canaug_traverse_edge(g, gens, property, loops=loops, sparse=sparse):\n                if extra_property(gg):\n                    yield copyfun(gg) if copy else gg\n        else:\n            raise NotImplementedError\n\n\n    def nauty_geng(self, options=\"\", debug=False):\n        r\"\"\"\n        Return a generator which creates graphs from nauty's geng program.\n\n        INPUT:\n\n        - ``options`` -- string (default: ``\"\"``); a string passed to ``geng``\n          as if it was run at a system command line. At a minimum, you *must*\n          pass the number of vertices you desire.  Sage expects the graphs to be\n          in nauty's \"graph6\" format, do not set an option to change this\n          default or results will be unpredictable.\n\n        - ``debug`` -- boolean (default: ``False``); if ``True`` the first line\n          of ``geng``'s output to standard error is captured and the first call\n          to the generator's ``next()`` function will return this line as a\n          string.  A line leading with \">A\" indicates a successful initiation of\n          the program with some information on the arguments, while a line\n          beginning with \">E\" indicates an error with the input.\n\n        The possible options, obtained as output of ``geng --help``::\n\n                 n       : the number of vertices\n            mine:maxe    : <int>:<int> a range for the number of edges\n                            <int>:0 means '<int> or more' except in the case 0:0\n              res/mod : only generate subset res out of subsets 0..mod-1\n\n                -c       : only write connected graphs\n                -C       : only write biconnected graphs\n                -t       : only generate triangle-free graphs\n                -f       : only generate 4-cycle-free graphs\n                -b       : only generate bipartite graphs\n                              (-t, -f and -b can be used in any combination)\n                -m       : save memory at the expense of time (only makes a\n                              difference in the absence of -b, -t, -f and n <= 28).\n                -d<int>  : a lower bound for the minimum degree\n                -D<int>  : a upper bound for the maximum degree\n                -v       : display counts by number of edges\n                -l       : canonically label output graphs\n\n                -q       : suppress auxiliary output (except from -v)\n\n        Options which cause ``geng`` to use an output format different than the\n        graph6 format are not listed above (-u, -g, -s, -y, -h) as they will\n        confuse the creation of a Sage graph.  The res/mod option can be useful\n        when using the output in a routine run several times in parallel.\n\n        OUTPUT:\n\n        A generator which will produce the graphs as Sage graphs.\n        These will be simple graphs: no loops, no multiple edges, no\n        directed edges.\n\n        .. SEEALSO::\n\n            :meth:`Graph.is_strongly_regular` -- tests whether a graph is\n            strongly regular and/or returns its parameters.\n\n        EXAMPLES:\n\n        The generator can be used to construct graphs for testing,\n        one at a time (usually inside a loop).  Or it can be used to\n        create an entire list all at once if there is sufficient memory\n        to contain it.  ::\n\n            sage: gen = graphs.nauty_geng(\"2\")\n            sage: next(gen)\n            Graph on 2 vertices\n            sage: next(gen)\n            Graph on 2 vertices\n            sage: next(gen)\n            Traceback (most recent call last):\n            ...\n            StopIteration\n\n        A list of all graphs on 7 vertices.  This agrees with\n        :oeis:`A000088`.  ::\n\n            sage: gen = graphs.nauty_geng(\"7\")\n            sage: len(list(gen))\n            1044\n\n        A list of just the connected graphs on 7 vertices.  This agrees with\n        :oeis:`A001349`.  ::\n\n            sage: gen = graphs.nauty_geng(\"7 -c\")\n            sage: len(list(gen))\n            853\n\n        A list of connected degree exactly 2 graphs on 5 vertices. ::\n\n            sage: gen = graphs.nauty_geng(\"5 -c -d2 -D2\")\n            sage: len(list(gen))\n            1\n\n        The ``debug`` switch can be used to examine ``geng``'s reaction to the\n        input in the ``options`` string.  We illustrate success.  (A failure\n        will be a string beginning with \">E\".)  Passing the \"-q\" switch to\n        ``geng`` will supress the indicator of a successful initiation, and so\n        the first returned value might be an empty string if ``debug`` is\n        ``True``::\n\n            sage: gen = graphs.nauty_geng(\"4\", debug=True)\n            sage: print(next(gen))\n            >A ...geng -d0D3 n=4 e=0-6\n            sage: gen = graphs.nauty_geng(\"4 -q\", debug=True)\n            sage: next(gen)\n            ''\n\n        TESTS:\n\n        Wrong input, ``\"-c3\"`` instead of ``\"-c 3\"`` (:trac:`14068`)::\n\n            sage: list(graphs.nauty_geng(\"-c3\", debug=False))\n            Traceback (most recent call last):\n            ...\n            ValueError: wrong format of parameter option\n            sage: list(graphs.nauty_geng(\"-c3\", debug=True))\n            ['>E Usage: ...geng [-cCmtfbd#D#] [-uygsnh] [-lvq] ...\n            sage: list(graphs.nauty_geng(\"-c 3\", debug=True))\n            ['>A ...geng -cd1D2 n=3 e=2-3\\n', Graph on 3 vertices, Graph on 3 vertices]\n        \"\"\"\n\n        sp = subprocess.Popen(nautyprefix+\"geng {0}\".format(options), shell=True,\n                              stdin=subprocess.PIPE, stdout=subprocess.PIPE,\n                              stderr=subprocess.PIPE, close_fds=True,\n                              encoding='latin-1')\n        msg = sp.stderr.readline()\n        if debug:\n            yield msg\n        elif msg.startswith('>E'):\n            raise ValueError('wrong format of parameter option')\n        gen = sp.stdout\n        while True:\n            try:\n                s = next(gen)\n            except StopIteration:\n                # Exhausted list of graphs from nauty geng\n                return\n            G = graph.Graph(s[:-1], format='graph6')\n            yield G\n\n\n    def cospectral_graphs(self, vertices, matrix_function=lambda g: g.adjacency_matrix(), graphs=None):\n        r\"\"\"\n        Find all sets of graphs on ``vertices`` vertices (with\n        possible restrictions) which are cospectral with respect to a\n        constructed matrix.\n\n        INPUT:\n\n        - ``vertices`` - The number of vertices in the graphs to be tested\n\n        - ``matrix_function`` - A function taking a graph and giving back\n          a matrix.  This defaults to the adjacency matrix.  The spectra\n          examined are the spectra of these matrices.\n\n        - ``graphs`` - One of three things:\n\n           - ``None`` (default) - test all graphs having ``vertices``\n             vertices\n\n           - a function taking a graph and returning ``True`` or ``False``\n             - test only the graphs on ``vertices`` vertices for which\n             the function returns ``True``\n\n           - a list of graphs (or other iterable object) - these graphs\n             are tested for cospectral sets.  In this case,\n             ``vertices`` is ignored.\n\n        OUTPUT:\n\n           A list of lists of graphs.  Each sublist will be a list of\n           cospectral graphs (lists of cardinality 1 being omitted).\n\n\n        .. SEEALSO::\n\n            :meth:`Graph.is_strongly_regular` -- tests whether a graph is\n            strongly regular and/or returns its parameters.\n\n        EXAMPLES::\n\n            sage: g=graphs.cospectral_graphs(5)\n            sage: sorted(sorted(g.graph6_string() for g in glist) for glist in g)\n            [['Dr?', 'Ds_']]\n            sage: g[0][1].am().charpoly()==g[0][1].am().charpoly()\n            True\n\n        There are two sets of cospectral graphs on six vertices with no isolated vertices::\n\n            sage: g=graphs.cospectral_graphs(6, graphs=lambda x: min(x.degree())>0)\n            sage: sorted(sorted(g.graph6_string() for g in glist) for glist in g)\n            [['Ep__', 'Er?G'], ['ExGg', 'ExoG']]\n            sage: g[0][1].am().charpoly()==g[0][1].am().charpoly()\n            True\n            sage: g[1][1].am().charpoly()==g[1][1].am().charpoly()\n            True\n\n        There is one pair of cospectral trees on eight vertices::\n\n            sage: g=graphs.cospectral_graphs(6, graphs=graphs.trees(8))\n            sage: sorted(sorted(g.graph6_string() for g in glist) for glist in g)\n            [['GiPC?C', 'GiQCC?']]\n            sage: g[0][1].am().charpoly()==g[0][1].am().charpoly()\n            True\n\n        There are two sets of cospectral graphs (with respect to the\n        Laplacian matrix) on six vertices::\n\n            sage: g=graphs.cospectral_graphs(6, matrix_function=lambda g: g.laplacian_matrix())\n            sage: sorted(sorted(g.graph6_string() for g in glist) for glist in g)\n            [['Edq_', 'ErcG'], ['Exoo', 'EzcG']]\n            sage: g[0][1].laplacian_matrix().charpoly()==g[0][1].laplacian_matrix().charpoly()\n            True\n            sage: g[1][1].laplacian_matrix().charpoly()==g[1][1].laplacian_matrix().charpoly()\n            True\n\n        To find cospectral graphs with respect to the normalized\n        Laplacian, assuming the graphs do not have an isolated vertex, it\n        is enough to check the spectrum of the matrix `D^{-1}A`, where `D`\n        is the diagonal matrix of vertex degrees, and A is the adjacency\n        matrix.  We find two such cospectral graphs (for the normalized\n        Laplacian) on five vertices::\n\n            sage: def DinverseA(g):\n            ....:   A=g.adjacency_matrix().change_ring(QQ)\n            ....:   for i in range(g.order()):\n            ....:       A.rescale_row(i, 1/len(A.nonzero_positions_in_row(i)))\n            ....:   return A\n            sage: g=graphs.cospectral_graphs(5, matrix_function=DinverseA, graphs=lambda g: min(g.degree())>0)\n            sage: sorted(sorted(g.graph6_string() for g in glist) for glist in g)\n            [['Dlg', 'Ds_']]\n            sage: g[0][1].laplacian_matrix(normalized=True).charpoly()==g[0][1].laplacian_matrix(normalized=True).charpoly()\n            True\n        \"\"\"\n        from sage.graphs.all import graphs as graph_gen\n        if graphs is None:\n            graph_list=graph_gen(vertices, property=lambda _: True)\n        elif callable(graphs):\n            graph_list=iter(g for g in graph_gen(vertices, property=lambda _: True) if graphs(g))\n        else:\n            graph_list=iter(graphs)\n\n        from collections import defaultdict\n        charpolys=defaultdict(list)\n        for g in graph_list:\n            cp=matrix_function(g).charpoly()\n            charpolys[cp].append(g)\n\n        cospectral_graphs=[]\n        for cp,g_list in charpolys.items():\n            if len(g_list)>1:\n                cospectral_graphs.append(g_list)\n\n        return cospectral_graphs\n\n    def _read_planar_code(self, code_input):\n        r\"\"\"\n        Returns a generator for the plane graphs in planar code format in\n        the file code_input (see [BM2016]_).\n\n        A file with planar code starts with a header ``>>planar_code<<``.\n        After the header each graph is stored in the following way :\n\n        The first character is the number of vertices, followed by\n        n11,...,n1k,null character,n21,...,n2k',null character, ...\n\n        where the n1* are all neighbors of n1 and all n2* are the\n        neighbors of n2, ...\n        Besides, these neighbors are enumerated in clockwise order.\n\n        INPUT:\n\n        - ``code_input`` - a file containing valid planar code data.\n\n        OUTPUT:\n\n        A generator which will produce the plane graphs as Sage graphs\n        with an embedding set. These will be simple graphs: no loops, no\n        multiple edges, no directed edges (unless plantri is asked to give\n        the dual graphs instead).\n\n        .. SEEALSO::\n\n            - :meth:`~sage.graphs.generic_graph.GenericGraph.set_embedding`,\n              :meth:`~sage.graphs.generic_graph.GenericGraph.get_embedding` --\n              get/set methods for embeddings.\n\n        EXAMPLES:\n\n        The following example creates a small planar code file in memory and\n        reads it using the ``_read_planar_code`` method::\n\n            sage: from io import StringIO\n            sage: code_input = StringIO('>>planar_code<<')\n            sage: _ = code_input.write('>>planar_code<<')\n            sage: for c in [4,2,3,4,0,1,4,3,0,1,2,4,0,1,3,2,0]:\n            ....:     _ = code_input.write('{:c}'.format(c))\n            sage: _ = code_input.seek(0)\n            sage: gen = graphs._read_planar_code(code_input)\n            sage: l = list(gen)\n            sage: l\n            [Graph on 4 vertices]\n            sage: l[0].is_isomorphic(graphs.CompleteGraph(4))\n            True\n            sage: l[0].get_embedding()\n            {1: [2, 3, 4],\n             2: [1, 4, 3],\n             3: [1, 2, 4],\n             4: [1, 3, 2]}\n        \"\"\"\n        #start of code to read planar code\n\n        header = code_input.read(15)\n        assert header == '>>planar_code<<', 'Not a valid planar code header'\n\n        #read graph per graph\n        while True:\n            c = code_input.read(1)\n            if len(c)==0:\n                return\n\n            # Each graph is stored in the following way :\n            #\n            # The first character is the number of vertices, followed by\n            # n11,...,n1k,null character,n21,...,n2k',null character, ...\n            #\n            # where the n1* are all neighbors of n1 and all n2* are the\n            # neighbors of n2, ...\n            #\n            # Besides, these neighbors are enumerated in clockwise order.\n            order = ord(c)\n\n            zeroCount = 0\n\n            g = [[] for i in range(order)]\n\n            while zeroCount < order:\n                c = code_input.read(1)\n                if ord(c) == 0:\n                    zeroCount += 1\n                else:\n                    g[zeroCount].append(ord(c))\n\n            # construct graph based on g\n\n            # first taking care that every edge is given twice\n            edges_g = {i + 1: [j for j in di if j < i + 1]\n                       for i, di in enumerate(g)}\n\n            # then adding half of the loops (if any)\n            has_loops = False\n            for i, di in enumerate(g):\n                Ni = di.count(i + 1)\n                if Ni > 1:\n                    edges_g[i + 1] += [i + 1] * (Ni // 2)\n                    has_loops = True\n            G = graph.Graph(edges_g, loops=has_loops)\n\n            if not(G.has_multiple_edges() or has_loops):\n                embed_g = {i + 1: di for i, di in enumerate(g)}\n                G.set_embedding(embed_g)\n            yield(G)\n\n    def fullerenes(self, order, ipr=False):\n        r\"\"\"\n        Returns a generator which creates fullerene graphs using\n        the buckygen generator (see [BGM2012]_).\n\n        INPUT:\n\n        - ``order`` - a positive even integer smaller than or equal to 254.\n          This specifies the number of vertices in the generated fullerenes.\n\n        - ``ipr`` - default: ``False`` - if ``True`` only fullerenes that\n          satisfy the Isolated Pentagon Rule are generated. This means that\n          no pentagonal faces share an edge.\n\n        OUTPUT:\n\n        A generator which will produce the fullerene graphs as Sage graphs\n        with an embedding set. These will be simple graphs: no loops, no\n        multiple edges, no directed edges.\n\n        .. SEEALSO::\n\n            - :meth:`~sage.graphs.generic_graph.GenericGraph.set_embedding`,\n              :meth:`~sage.graphs.generic_graph.GenericGraph.get_embedding` --\n              get/set methods for embeddings.\n\n        EXAMPLES:\n\n        There are 1812 isomers of `\\textrm{C}_{60}`, i.e., 1812 fullerene graphs\n        on 60 vertices::\n\n            sage: gen = graphs.fullerenes(60)  # optional buckygen\n            sage: len(list(gen))  # optional buckygen\n            1812\n\n        However, there is only one IPR fullerene graph on 60 vertices: the famous\n        Buckminster Fullerene::\n\n            sage: gen = graphs.fullerenes(60, ipr=True)  # optional buckygen\n            sage: next(gen)  # optional buckygen\n            Graph on 60 vertices\n            sage: next(gen)  # optional buckygen\n            Traceback (most recent call last):\n            ...\n            StopIteration\n\n        The unique fullerene graph on 20 vertices is isomorphic to the dodecahedron\n        graph. ::\n\n            sage: gen = graphs.fullerenes(20)  # optional buckygen\n            sage: g = next(gen)  # optional buckygen\n            sage: g.is_isomorphic(graphs.DodecahedralGraph()) # optional buckygen\n            True\n            sage: g.get_embedding()  # optional buckygen\n            {1: [2, 3, 4],\n             2: [1, 5, 6],\n             3: [1, 7, 8],\n             4: [1, 9, 10],\n             5: [2, 10, 11],\n             6: [2, 12, 7],\n             7: [3, 6, 13],\n             8: [3, 14, 9],\n             9: [4, 8, 15],\n             10: [4, 16, 5],\n             11: [5, 17, 12],\n             12: [6, 11, 18],\n             13: [7, 18, 14],\n             14: [8, 13, 19],\n             15: [9, 19, 16],\n             16: [10, 15, 17],\n             17: [11, 16, 20],\n             18: [12, 20, 13],\n             19: [14, 20, 15],\n             20: [17, 19, 18]}\n            sage: g.plot3d(layout='spring')  # optional buckygen\n            Graphics3d Object\n        \"\"\"\n        # number of vertices should be positive\n        if order < 0:\n            raise ValueError(\"number of vertices should be non-negative\")\n\n        # buckygen can only output fullerenes on up to 254 vertices\n        if order > 254:\n            raise ValueError(\"number of vertices should be at most 254\")\n\n        # fullerenes only exist for an even number of vertices, larger than 20\n        # and different from 22\n        if order % 2 == 1 or order < 20 or order == 22:\n            return\n\n        from sage.features.graph_generators import Buckygen\n        Buckygen().require()\n\n        command = 'buckygen -'+('I' if ipr else '')+'d {0}d'.format(order)\n\n        sp = subprocess.Popen(command, shell=True,\n                              stdin=subprocess.PIPE, stdout=subprocess.PIPE,\n                              stderr=subprocess.PIPE, close_fds=True,\n                              encoding='latin-1')\n\n        sp.stdout.reconfigure(newline='')\n\n        for G in graphs._read_planar_code(sp.stdout):\n            yield(G)\n\n    def fusenes(self, hexagon_count, benzenoids=False):\n        r\"\"\"\n        Returns a generator which creates fusenes and benzenoids using\n        the benzene generator (see [BCH2002]_). Fusenes are planar\n        polycyclic hydrocarbons with all bounded faces hexagons. Benzenoids\n        are fusenes that are subgraphs of the hexagonal lattice.\n\n        INPUT:\n\n        - ``hexagon_count`` - a positive integer smaller than or equal to 30.\n          This specifies the number of hexagons in the generated benzenoids.\n\n        - ``benzenoids`` - default: ``False`` - if ``True`` only benzenoids are\n          generated.\n\n        OUTPUT:\n\n        A generator which will produce the fusenes as Sage graphs\n        with an embedding set. These will be simple graphs: no loops, no\n        multiple edges, no directed edges.\n\n        .. SEEALSO::\n\n            - :meth:`~sage.graphs.generic_graph.GenericGraph.set_embedding`,\n              :meth:`~sage.graphs.generic_graph.GenericGraph.get_embedding` --\n              get/set methods for embeddings.\n\n        EXAMPLES:\n\n        There is a unique fusene with 2 hexagons::\n\n            sage: gen = graphs.fusenes(2)  # optional benzene\n            sage: len(list(gen))  # optional benzene\n            1\n\n        This fusene is naphthalene (`\\textrm{C}_{10}\\textrm{H}_{8}`).\n        In the fusene graph the H-atoms are not stored, so this is\n        a graph on just 10 vertices::\n\n            sage: gen = graphs.fusenes(2)  # optional benzene\n            sage: next(gen)  # optional benzene\n            Graph on 10 vertices\n            sage: next(gen)  # optional benzene\n            Traceback (most recent call last):\n            ...\n            StopIteration\n\n        There are 6505 benzenoids with 9 hexagons::\n\n            sage: gen = graphs.fusenes(9, benzenoids=True)  # optional benzene\n            sage: len(list(gen))  # optional benzene\n            6505\n        \"\"\"\n        if hexagon_count < 0:\n            raise ValueError(\"number of hexagons should be non-negative\")\n\n        # benzene is only built for fusenes with up to 30 hexagons\n        if hexagon_count > 30:\n            raise ValueError(\"number of hexagons should be at most 30\")\n\n        # there are no fusenes with 0 hexagons\n        if hexagon_count == 0:\n            return\n\n        # there is only one unique fusene with 1 hexagon (and benzene doesn't generate it)\n        if hexagon_count == 1:\n            g = {1:[6, 2], 2:[1, 3], 3:[2, 4], 4:[3, 5], 5:[4, 6], 6:[5, 1]}\n            G = graph.Graph(g)\n            G.set_embedding(g)\n            yield(G)\n            return\n\n        from sage.features.graph_generators import Benzene\n        Benzene().require()\n\n        command = 'benzene '+('b' if benzenoids else '')+' {0} p'.format(hexagon_count)\n\n        sp = subprocess.Popen(command, shell=True,\n                              stdin=subprocess.PIPE, stdout=subprocess.PIPE,\n                              stderr=subprocess.PIPE, close_fds=True,\n                              encoding='latin-1')\n\n        sp.stdout.reconfigure(newline='')\n\n        for G in graphs._read_planar_code(sp.stdout):\n            yield(G)\n\n    def planar_graphs(self, order, minimum_degree=None,\n                      minimum_connectivity=None,\n                      exact_connectivity=False, only_bipartite=False,\n                      dual=False):\n        r\"\"\"\n        An iterator over connected planar graphs using the plantri generator.\n\n        This uses the plantri generator (see [BM2007]_) which is available\n        through the optional package plantri.\n\n        .. NOTE::\n\n            The non-3-connected graphs will be returned several times, with all\n            its possible embeddings.\n\n        INPUT:\n\n        - ``order`` - a positive integer smaller than or equal to 64.\n          This specifies the number of vertices in the generated graphs.\n\n        - ``minimum_degree`` - default: ``None`` - a value `\\geq 1` and `\\leq\n          5`, or ``None``. This specifies the minimum degree of the generated\n          graphs. If this is ``None`` and the order is 1, then this is set to\n          0. If this is ``None`` and the minimum connectivity is specified, then\n          this is set to the same value as the minimum connectivity.  If the\n          minimum connectivity is also equal to ``None``, then this is set to 1.\n\n        - ``minimum_connectivity`` - default: ``None`` - a value `\\geq 1`\n          and `\\leq 3`, or ``None``. This specifies the minimum connectivity of the\n          generated graphs. If this is ``None`` and the minimum degree is\n          specified, then this is set to the minimum of the minimum degree\n          and 3. If the minimum degree is also equal to ``None``, then this\n          is set to 1.\n\n        - ``exact_connectivity`` - default: ``False`` - if ``True`` only\n          graphs with exactly the specified connectivity will be generated.\n          This option cannot be used with ``minimum_connectivity=3``, or if\n          the minimum connectivity is not explicitly set.\n\n        - ``only_bipartite`` - default: ``False`` - if ``True`` only bipartite\n          graphs will be generated. This option cannot be used for graphs with\n          a minimum degree larger than 3.\n\n        - ``dual`` - default: ``False`` - if ``True`` return instead the\n          planar duals of the generated graphs.\n\n        OUTPUT:\n\n        An iterator which will produce all planar graphs with the given\n        number of vertices as Sage graphs with an embedding set. These will be\n        simple graphs (no loops, no multiple edges, no directed edges)\n        unless the option ``dual=True`` is used.\n\n        .. SEEALSO::\n\n            - :meth:`~sage.graphs.generic_graph.GenericGraph.set_embedding`,\n              :meth:`~sage.graphs.generic_graph.GenericGraph.get_embedding` --\n              get/set methods for embeddings.\n\n        EXAMPLES:\n\n        There are 6 planar graphs on 4 vertices::\n\n            sage: gen = graphs.planar_graphs(4)  # optional plantri\n            sage: len(list(gen))  # optional plantri\n            6\n\n        Three of these planar graphs are bipartite::\n\n            sage: gen = graphs.planar_graphs(4, only_bipartite=True)  # optional plantri\n            sage: len(list(gen))  # optional plantri\n            3\n\n        Setting ``dual=True`` gives the planar dual graphs::\n\n            sage: gen = graphs.planar_graphs(4, dual=True)  # optional plantri\n            sage: [u for u in list(gen)]  # optional plantri\n            [Graph on 4 vertices,\n            Multi-graph on 3 vertices,\n            Multi-graph on 2 vertices,\n            Looped multi-graph on 2 vertices,\n            Looped multi-graph on 1 vertex,\n            Looped multi-graph on 1 vertex]\n\n        The cycle of length 4 is the only 2-connected bipartite planar graph\n        on 4 vertices::\n\n            sage: l = list(graphs.planar_graphs(4, minimum_connectivity=2, only_bipartite=True))  # optional plantri\n            sage: l[0].get_embedding()  # optional plantri\n            {1: [2, 3],\n             2: [1, 4],\n             3: [1, 4],\n             4: [2, 3]}\n\n        There is one planar graph with one vertex. This graph obviously has\n        minimum degree equal to 0::\n\n            sage: list(graphs.planar_graphs(1))  # optional plantri\n            [Graph on 1 vertex]\n            sage: list(graphs.planar_graphs(1, minimum_degree=1))  # optional plantri\n            []\n\n        TESTS:\n\n        The number of edges in a planar graph is equal to the number of edges in\n        its dual::\n\n            sage: planar      = list(graphs.planar_graphs(5,dual=True))  # optional -- plantri\n            sage: dual_planar = list(graphs.planar_graphs(5,dual=False)) # optional -- plantri\n            sage: planar_sizes      = [g.size() for g in planar]         # optional -- plantri\n            sage: dual_planar_sizes = [g.size() for g in dual_planar]    # optional -- plantri\n            sage: planar_sizes == dual_planar_sizes                      # optional -- plantri\n            True\n        \"\"\"\n        if order < 0:\n            raise ValueError(\"number of vertices should be non-negative\")\n\n        # plantri can only output general planar graphs on up to 64 vertices\n        if order > 64:\n            raise ValueError(\"number of vertices should be at most 64\")\n\n        if exact_connectivity and minimum_connectivity is None:\n            raise ValueError(\"Minimum connectivity must be specified to use the exact_connectivity option.\")\n\n        if minimum_connectivity is  not None and not (1 <= minimum_connectivity <= 3):\n            raise ValueError(\"Minimum connectivity should be a number between 1 and 3.\")\n\n        # minimum degree should be None or a number between 1 and 5\n        if minimum_degree == 0:\n            if order != 1:\n                raise ValueError(\"Minimum degree equal to 0 is only possible if the graphs have 1 vertex.\")\n        elif minimum_degree is not None and not (1 <= minimum_degree <= 5):\n            raise ValueError(\"Minimum degree should be a number between 1 and 5 if the order is greater than 1.\")\n        elif minimum_degree is None and order == 1:\n            minimum_degree = 0\n\n        # check combination of values of minimum degree and minimum connectivity\n        if minimum_connectivity is None:\n            if minimum_degree is not None:\n                minimum_connectivity = min(3, minimum_degree)\n            elif minimum_degree is None:\n                minimum_degree, minimum_connectivity = 1, 1\n        else:\n            if minimum_degree is None:\n                minimum_degree = minimum_connectivity\n            elif (minimum_degree < minimum_connectivity and\n                  minimum_degree > 0):\n                raise ValueError(\"Minimum connectivity can be at most the minimum degree.\")\n\n        #exact connectivity is not implemented for minimum connectivity 3\n        if exact_connectivity and minimum_connectivity==3:\n            raise NotImplementedError(\"Generation of planar graphs with connectivity exactly 3 is not implemented.\")\n\n        if only_bipartite and minimum_degree > 3:\n            raise NotImplementedError(\"Generation of bipartite planar graphs with minimum degree 4 or 5 is not implemented.\")\n\n        if order == 0:\n            return\n\n        minimum_order = {0:1, 1:2, 2:3, 3:4, 4:6, 5:12}[minimum_degree]\n\n        if order < minimum_order:\n            return\n\n        if order == 1:\n            if minimum_degree == 0:\n                G = graph.Graph(1)\n                G.set_embedding({0: []})\n                yield(G)\n            return\n\n        from sage.features.graph_generators import Plantri\n        Plantri().require()\n\n        cmd = 'plantri -p{}m{}c{}{}{} {}'\n        command = cmd.format('b' if only_bipartite else '',\n                             minimum_degree,\n                             minimum_connectivity,\n                             'x' if exact_connectivity else '',\n                             'd' if dual else '',\n                             order)\n\n        sp = subprocess.Popen(command, shell=True,\n                              stdin=subprocess.PIPE, stdout=subprocess.PIPE,\n                              stderr=subprocess.PIPE, close_fds=True,\n                              encoding='latin-1')\n\n        sp.stdout.reconfigure(newline='')\n\n        for G in graphs._read_planar_code(sp.stdout):\n            yield(G)\n\n    def triangulations(self, order, minimum_degree=None, minimum_connectivity=None,\n                       exact_connectivity=False, only_eulerian=False, dual=False):\n        r\"\"\"\n        An iterator over connected planar triangulations using the plantri generator.\n\n        This uses the plantri generator (see [BM2007]_) which is available\n        through the optional package plantri.\n\n        INPUT:\n\n        - ``order`` - a positive integer smaller than or equal to 64.\n          This specifies the number of vertices in the generated triangulations.\n\n        - ``minimum_degree`` - default: ``None`` - a value `\\geq 3` and `\\leq 5`,\n          or ``None``. This specifies the minimum degree of the generated\n          triangulations. If this is ``None`` and the minimum connectivity\n          is specified, then this is set to the same value as the minimum\n          connectivity. If the minimum connectivity is also equal to ``None``,\n          then this is set to 3.\n\n        - ``minimum_connectivity`` - default: ``None`` - a value `\\geq 3` and\n          `\\leq 5`, or ``None``. This specifies the minimum connectivity of the\n          generated triangulations. If this is ``None`` and the minimum degree\n          is specified, then this is set to the minimum of the minimum degree\n          and 3. If the minimum degree is also equal to ``None``, then this is\n          set to 3.\n\n        - ``exact_connectivity`` - default: ``False`` - if ``True`` only\n          triangulations with exactly the specified connectivity will be generated.\n          This option cannot be used with ``minimum_connectivity=3``, or if\n          the minimum connectivity is not explicitly set.\n\n        - ``only_eulerian`` - default: ``False`` - if ``True`` only Eulerian\n          triangulations will be generated. This option cannot be used if the\n          minimum degree is explicitly set to anything else than 4.\n\n        - ``dual`` - default: ``False`` - if ``True`` return instead the\n          planar duals of the generated graphs.\n\n        OUTPUT:\n\n        An iterator which will produce all planar triangulations with the given\n        number of vertices as Sage graphs with an embedding set. These will be\n        simple graphs (no loops, no multiple edges, no directed edges).\n\n        .. SEEALSO::\n\n            - :meth:`~sage.graphs.generic_graph.GenericGraph.set_embedding`,\n              :meth:`~sage.graphs.generic_graph.GenericGraph.get_embedding` --\n              get/set methods for embeddings.\n\n            - :meth:`~sage.graphs.graph_generators.GraphGenerators.RandomTriangulation`\n              -- build a random triangulation.\n\n        EXAMPLES:\n\n        The unique planar embedding of the `K_4` is the only planar triangulations\n        on 4 vertices::\n\n            sage: gen = graphs.triangulations(4)    # optional plantri\n            sage: [g.get_embedding() for g in gen]  # optional plantri\n            [{1: [2, 3, 4], 2: [1, 4, 3], 3: [1, 2, 4], 4: [1, 3, 2]}]\n\n        but, of course, this graph is not Eulerian::\n\n            sage: gen = graphs.triangulations(4, only_eulerian=True)  # optional plantri\n            sage: len(list(gen))                                      # optional plantri\n            0\n\n        The unique Eulerian triangulation on 6 vertices is isomorphic to the octahedral\n        graph. ::\n\n            sage: gen = graphs.triangulations(6, only_eulerian=True)  # optional plantri\n            sage: g = next(gen)                                       # optional plantri\n            sage: g.is_isomorphic(graphs.OctahedralGraph())           # optional plantri\n            True\n\n        An overview of the number of 5-connected triangulations on up to 22 vertices. This\n        agrees with :oeis:`A081621`::\n\n            sage: for i in range(12, 23):                                             # optional plantri\n            ....:     L = len(list(graphs.triangulations(i, minimum_connectivity=5))) # optional plantri\n            ....:     print(\"{}   {:3d}\".format(i,L))                                 # optional plantri\n            12     1\n            13     0\n            14     1\n            15     1\n            16     3\n            17     4\n            18    12\n            19    23\n            20    71\n            21   187\n            22   627\n\n        The minimum connectivity can be at most the minimum degree::\n\n            sage: gen = next(graphs.triangulations(10, minimum_degree=3, minimum_connectivity=5))  # optional plantri\n            Traceback (most recent call last):\n            ...\n            ValueError: Minimum connectivity can be at most the minimum degree.\n\n        There are 5 triangulations with 9 vertices and minimum degree equal to 4\n        that are 3-connected, but only one of them is not 4-connected::\n\n            sage: len([g for g in graphs.triangulations(9, minimum_degree=4, minimum_connectivity=3)]) # optional plantri\n            5\n            sage: len([g for g in graphs.triangulations(9, minimum_degree=4, minimum_connectivity=3, exact_connectivity=True)]) # optional plantri\n            1\n\n        Setting ``dual=True`` gives the planar dual graphs::\n\n            sage: [len(g) for g in graphs.triangulations(9, minimum_degree=4, minimum_connectivity=3, dual=True)]  # optional plantri\n            [14, 14, 14, 14, 14]\n\n        TESTS::\n\n            sage: [g.size() for g in graphs.triangulations(6, minimum_connectivity=3)] # optional plantri\n            [12, 12]\n        \"\"\"\n        if order < 0:\n            raise ValueError(\"number of vertices should be non-negative\")\n\n        # plantri can only output planar triangulations on up to 64 vertices\n        if order > 64:\n            raise ValueError(\"number of vertices should be at most 64\")\n\n        if exact_connectivity and minimum_connectivity is None:\n            raise ValueError(\"Minimum connectivity must be specified to use the exact_connectivity option.\")\n\n        if minimum_connectivity is  not None and not (3 <= minimum_connectivity <= 5):\n            raise ValueError(\"Minimum connectivity should be None or a number between 3 and 5.\")\n\n        if minimum_degree is  not None and not (3 <= minimum_degree <= 5):\n            raise ValueError(\"Minimum degree should be None or a number between 3 and 5.\")\n\n        # for Eulerian triangulations the minimum degree is set to 4 (unless it was already specifically set)\n        if only_eulerian and minimum_degree is None:\n            minimum_degree = 4\n\n        # check combination of values of minimum degree and minimum connectivity\n        if minimum_connectivity is None:\n            if minimum_degree is not None:\n                minimum_connectivity = min(3, minimum_degree)\n            else:\n                minimum_degree, minimum_connectivity = 3, 3\n        else:\n            if minimum_degree is None:\n                minimum_degree = minimum_connectivity\n            elif minimum_degree < minimum_connectivity:\n                raise ValueError(\"Minimum connectivity can be at most the minimum degree.\")\n\n        #exact connectivity is not implemented for minimum connectivity equal to minimum degree\n        if exact_connectivity and minimum_connectivity==minimum_degree:\n            raise NotImplementedError(\"Generation of triangulations with minimum connectivity equal to minimum degree is not implemented.\")\n\n        minimum_order = {3:4, 4:6, 5:12}[minimum_degree]\n\n        if order < minimum_order:\n            return\n\n        if only_eulerian and order < 6:\n            return\n\n        from sage.features.graph_generators import Plantri\n        Plantri().require()\n\n        cmd = 'plantri -{}m{}c{}{}{} {}'\n        command = cmd.format('b' if only_eulerian else '',\n                             minimum_degree,\n                             minimum_connectivity,\n                             'x' if exact_connectivity else '',\n                             'd' if dual else '',\n                             order)\n\n        sp = subprocess.Popen(command, shell=True,\n                              stdin=subprocess.PIPE, stdout=subprocess.PIPE,\n                              stderr=subprocess.PIPE, close_fds=True,\n                              encoding='latin-1')\n\n        sp.stdout.reconfigure(newline='')\n\n        for G in graphs._read_planar_code(sp.stdout):\n            yield(G)\n\n    def quadrangulations(self, order, minimum_degree=None, minimum_connectivity=None,\n                         no_nonfacial_quadrangles=False, dual=False):\n        r\"\"\"\n        An iterator over planar quadrangulations using the plantri generator.\n\n        This uses the plantri generator (see [BM2007]_) which is available\n        through the optional package plantri.\n\n        INPUT:\n\n        - ``order`` - a positive integer smaller than or equal to 64.\n          This specifies the number of vertices in the generated quadrangulations.\n\n        - ``minimum_degree`` - default: ``None`` - a value `\\geq 2` and `\\leq\n          3`, or ``None``. This specifies the minimum degree of the generated\n          quadrangulations. If this is ``None`` and the minimum connectivity is\n          specified, then this is set to the same value as the minimum\n          connectivity. If the minimum connectivity is also equal to ``None``,\n          then this is set to 2.\n\n        - ``minimum_connectivity`` - default: ``None`` - a value `\\geq 2` and\n          `\\leq 3`, or ``None``. This specifies the minimum connectivity of the\n          generated quadrangulations. If this is ``None`` and the option\n          ``no_nonfacial_quadrangles`` is set to ``True``, then this is set to\n          3. Otherwise if this is ``None`` and the minimum degree is specified,\n          then this is set to the minimum degree. If the minimum degree is also\n          equal to ``None``, then this is set to 3.\n\n        - ``no_nonfacial_quadrangles`` - default: ``False`` - if ``True`` only\n          quadrangulations with no non-facial quadrangles are generated. This\n          option cannot be used if ``minimum_connectivity`` is set to 2.\n\n        - ``dual`` - default: ``False`` - if ``True`` return instead the\n          planar duals of the generated graphs.\n\n        OUTPUT:\n\n        An iterator which will produce all planar quadrangulations with the given\n        number of vertices as Sage graphs with an embedding set. These will be\n        simple graphs (no loops, no multiple edges, no directed edges).\n\n        .. SEEALSO::\n\n            - :meth:`~sage.graphs.generic_graph.GenericGraph.set_embedding`,\n              :meth:`~sage.graphs.generic_graph.GenericGraph.get_embedding` --\n              get/set methods for embeddings.\n\n        EXAMPLES:\n\n        The cube is the only 3-connected planar quadrangulation on 8 vertices::\n\n            sage: gen = graphs.quadrangulations(8, minimum_connectivity=3)  # optional plantri\n            sage: g = next(gen)                                            # optional plantri\n            sage: g.is_isomorphic(graphs.CubeGraph(3))                      # optional plantri\n            True\n            sage: next(gen)                                                # optional plantri\n            Traceback (most recent call last):\n            ...\n            StopIteration\n\n        An overview of the number of quadrangulations on up to 12 vertices. This\n        agrees with :oeis:`A113201`::\n\n            sage: for i in range(4,13):                          # optional plantri\n            ....:     L =  len(list(graphs.quadrangulations(i))) # optional plantri\n            ....:     print(\"{:2d}   {:3d}\".format(i,L))         # optional plantri\n             4     1\n             5     1\n             6     2\n             7     3\n             8     9\n             9    18\n            10    62\n            11   198\n            12   803\n\n        There are 2 planar quadrangulation on 12 vertices that do not have a\n        non-facial quadrangle::\n\n            sage: len([g for g in graphs.quadrangulations(12, no_nonfacial_quadrangles=True)])  # optional plantri\n            2\n\n        Setting ``dual=True`` gives the planar dual graphs::\n\n            sage: [len(g) for g in graphs.quadrangulations(12, no_nonfacial_quadrangles=True, dual=True)]  # optional plantri\n            [10, 10]\n        \"\"\"\n        if order < 0:\n            raise ValueError(\"number of vertices should be non-negative\")\n\n        # plantri can only output planar quadrangulations on up to 64 vertices\n        if order > 64:\n            raise ValueError(\"number of vertices should be at most 64\")\n\n        if minimum_connectivity not in {None, 2, 3}:\n            raise ValueError(\"Minimum connectivity should be None, 2 or 3.\")\n\n        if minimum_degree not in {None, 2, 3}:\n            raise ValueError(\"Minimum degree should be None, 2 or 3.\")\n\n        if (no_nonfacial_quadrangles and\n            minimum_connectivity == 2):\n                raise NotImplementedError(\"Generation of no non-facial quadrangles and minimum connectivity 2 is not implemented\")\n\n        # check combination of values of minimum degree and minimum connectivity\n        if minimum_connectivity is None:\n            if minimum_degree is not None:\n                minimum_connectivity = min(2, minimum_degree)\n            else:\n                minimum_degree, minimum_connectivity = 2, 2\n        else:\n            if minimum_degree is None:\n                minimum_degree = minimum_connectivity\n            elif minimum_degree < minimum_connectivity:\n                raise ValueError(\"Minimum connectivity can be at most the minimum degree.\")\n\n        minimum_order = {2:4, 3:8}[minimum_degree]\n\n        if order < minimum_order:\n            return\n\n        if no_nonfacial_quadrangles:\n            # for plantri -q the option -c4 means 3-connected with no non-facial quadrangles\n            minimum_connectivity = 4\n\n        from sage.features.graph_generators import Plantri\n        Plantri().require()\n\n        cmd = 'plantri -qm{}c{}{} {}'\n        command = cmd.format(minimum_degree,\n                             minimum_connectivity,\n                             'd' if dual else '',\n                             order)\n\n        sp = subprocess.Popen(command, shell=True,\n                              stdin=subprocess.PIPE, stdout=subprocess.PIPE,\n                              stderr=subprocess.PIPE, close_fds=True,\n                              encoding='latin-1')\n\n        sp.stdout.reconfigure(newline='')\n\n        for G in graphs._read_planar_code(sp.stdout):\n            yield(G)\n\n###########################################################################\n# Basic Graphs\n###########################################################################\n    from .generators import basic\n    BullGraph                = staticmethod(basic.BullGraph)\n    ButterflyGraph           = staticmethod(basic.ButterflyGraph)\n    CircularLadderGraph      = staticmethod(basic.CircularLadderGraph)\n    ClawGraph                = staticmethod(basic.ClawGraph)\n    CycleGraph               = staticmethod(basic.CycleGraph)\n    CompleteGraph            = staticmethod(basic.CompleteGraph)\n    CompleteBipartiteGraph   = staticmethod(basic.CompleteBipartiteGraph)\n    CompleteMultipartiteGraph= staticmethod(basic.CompleteMultipartiteGraph)\n    DiamondGraph             = staticmethod(basic.DiamondGraph)\n    GemGraph                 = staticmethod(basic.GemGraph)\n    DartGraph                = staticmethod(basic.DartGraph)\n    ForkGraph                = staticmethod(basic.ForkGraph)\n    EmptyGraph               = staticmethod(basic.EmptyGraph)\n    Grid2dGraph              = staticmethod(basic.Grid2dGraph)\n    GridGraph                = staticmethod(basic.GridGraph)\n    HouseGraph               = staticmethod(basic.HouseGraph)\n    HouseXGraph              = staticmethod(basic.HouseXGraph)\n    LadderGraph              = staticmethod(basic.LadderGraph)\n    PathGraph                = staticmethod(basic.PathGraph)\n    StarGraph                = staticmethod(basic.StarGraph)\n    Toroidal6RegularGrid2dGraph = staticmethod(basic.Toroidal6RegularGrid2dGraph)\n    ToroidalGrid2dGraph      = staticmethod(basic.ToroidalGrid2dGraph)\n\n###########################################################################\n# Small Graphs\n###########################################################################\n    from .generators import smallgraphs, distance_regular\n    Balaban10Cage            = staticmethod(smallgraphs.Balaban10Cage)\n    Balaban11Cage            = staticmethod(smallgraphs.Balaban11Cage)\n    BidiakisCube             = staticmethod(smallgraphs.BidiakisCube)\n    BiggsSmithGraph          = staticmethod(smallgraphs.BiggsSmithGraph)\n    BlanusaFirstSnarkGraph   = staticmethod(smallgraphs.BlanusaFirstSnarkGraph)\n    BlanusaSecondSnarkGraph  = staticmethod(smallgraphs.BlanusaSecondSnarkGraph)\n    BrinkmannGraph           = staticmethod(smallgraphs.BrinkmannGraph)\n    BrouwerHaemersGraph      = staticmethod(smallgraphs.BrouwerHaemersGraph)\n    BuckyBall                = staticmethod(smallgraphs.BuckyBall)\n    CameronGraph             = staticmethod(smallgraphs.CameronGraph)\n    Cell600                  = staticmethod(smallgraphs.Cell600)\n    Cell120                  = staticmethod(smallgraphs.Cell120)\n    ChvatalGraph             = staticmethod(smallgraphs.ChvatalGraph)\n    ClebschGraph             = staticmethod(smallgraphs.ClebschGraph)\n    cocliques_HoffmannSingleton = staticmethod(distance_regular.cocliques_HoffmannSingleton)\n    ConwaySmith_for_3S7      = staticmethod(distance_regular.ConwaySmith_for_3S7)\n    CoxeterGraph             = staticmethod(smallgraphs.CoxeterGraph)\n    DejterGraph              = staticmethod(smallgraphs.DejterGraph)\n    DesarguesGraph           = staticmethod(smallgraphs.DesarguesGraph)\n    distance_3_doubly_truncated_Golay_code_graph = staticmethod(distance_regular.distance_3_doubly_truncated_Golay_code_graph)\n    DoubleStarSnark          = staticmethod(smallgraphs.DoubleStarSnark)\n    DoublyTruncatedWittGraph = staticmethod(distance_regular.DoublyTruncatedWittGraph)\n    DurerGraph               = staticmethod(smallgraphs.DurerGraph)\n    DyckGraph                = staticmethod(smallgraphs.DyckGraph)\n    EllinghamHorton54Graph   = staticmethod(smallgraphs.EllinghamHorton54Graph)\n    EllinghamHorton78Graph   = staticmethod(smallgraphs.EllinghamHorton78Graph)\n    ErreraGraph              = staticmethod(smallgraphs.ErreraGraph)\n    F26AGraph                = staticmethod(smallgraphs.F26AGraph)\n    FlowerSnark              = staticmethod(smallgraphs.FlowerSnark)\n    FolkmanGraph             = staticmethod(smallgraphs.FolkmanGraph)\n    FosterGraph              = staticmethod(smallgraphs.FosterGraph)\n    FosterGraph3S6           = staticmethod(distance_regular.FosterGraph3S6)\n    FranklinGraph            = staticmethod(smallgraphs.FranklinGraph)\n    FruchtGraph              = staticmethod(smallgraphs.FruchtGraph)\n    GoldnerHararyGraph       = staticmethod(smallgraphs.GoldnerHararyGraph)\n    GolombGraph              = staticmethod(smallgraphs.GolombGraph)\n    GossetGraph              = staticmethod(smallgraphs.GossetGraph)\n    graph_3O73               = staticmethod(distance_regular.graph_3O73)\n    GrayGraph                = staticmethod(smallgraphs.GrayGraph)\n    GrotzschGraph            = staticmethod(smallgraphs.GrotzschGraph)\n    HallJankoGraph           = staticmethod(smallgraphs.HallJankoGraph)\n    WellsGraph               = staticmethod(smallgraphs.WellsGraph)\n    HarborthGraph            = staticmethod(smallgraphs.HarborthGraph)\n    HarriesGraph             = staticmethod(smallgraphs.HarriesGraph)\n    HarriesWongGraph         = staticmethod(smallgraphs.HarriesWongGraph)\n    HeawoodGraph             = staticmethod(smallgraphs.HeawoodGraph)\n    HerschelGraph            = staticmethod(smallgraphs.HerschelGraph)\n    HigmanSimsGraph          = staticmethod(smallgraphs.HigmanSimsGraph)\n    HoffmanGraph             = staticmethod(smallgraphs.HoffmanGraph)\n    HoffmanSingletonGraph    = staticmethod(smallgraphs.HoffmanSingletonGraph)\n    HoltGraph                = staticmethod(smallgraphs.HoltGraph)\n    HortonGraph              = staticmethod(smallgraphs.HortonGraph)\n    IoninKharaghani765Graph  = staticmethod(smallgraphs.IoninKharaghani765Graph)\n    IvanovIvanovFaradjevGraph = staticmethod(distance_regular.IvanovIvanovFaradjevGraph)\n    J2Graph                  = staticmethod(distance_regular.J2Graph)\n    JankoKharaghaniGraph     = staticmethod(smallgraphs.JankoKharaghaniGraph)\n    JankoKharaghaniTonchevGraph  = staticmethod(smallgraphs.JankoKharaghaniTonchevGraph)\n    KittellGraph             = staticmethod(smallgraphs.KittellGraph)\n    KrackhardtKiteGraph      = staticmethod(smallgraphs.KrackhardtKiteGraph)\n    Klein3RegularGraph       = staticmethod(smallgraphs.Klein3RegularGraph)\n    Klein7RegularGraph       = staticmethod(smallgraphs.Klein7RegularGraph)\n    LargeWittGraph           = staticmethod(distance_regular.LargeWittGraph)\n    LeonardGraph             = staticmethod(distance_regular.LeonardGraph)\n    LjubljanaGraph           = staticmethod(smallgraphs.LjubljanaGraph)\n    vanLintSchrijverGraph       = staticmethod(distance_regular.vanLintSchrijverGraph)\n    LivingstoneGraph         = staticmethod(smallgraphs.LivingstoneGraph)\n    locally_GQ42_distance_transitive_graph = staticmethod(distance_regular.locally_GQ42_distance_transitive_graph)\n    LocalMcLaughlinGraph     = staticmethod(smallgraphs.LocalMcLaughlinGraph)\n    M22Graph                 = staticmethod(smallgraphs.M22Graph)\n    MarkstroemGraph          = staticmethod(smallgraphs.MarkstroemGraph)\n    MathonStronglyRegularGraph = staticmethod(smallgraphs.MathonStronglyRegularGraph)\n    McGeeGraph               = staticmethod(smallgraphs.McGeeGraph)\n    McLaughlinGraph          = staticmethod(smallgraphs.McLaughlinGraph)\n    MeredithGraph            = staticmethod(smallgraphs.MeredithGraph)\n    MoebiusKantorGraph       = staticmethod(smallgraphs.MoebiusKantorGraph)\n    MoserSpindle             = staticmethod(smallgraphs.MoserSpindle)\n    NauruGraph               = staticmethod(smallgraphs.NauruGraph)\n    PappusGraph              = staticmethod(smallgraphs.PappusGraph)\n    PoussinGraph             = staticmethod(smallgraphs.PoussinGraph)\n    PerkelGraph              = staticmethod(smallgraphs.PerkelGraph)\n    PetersenGraph            = staticmethod(smallgraphs.PetersenGraph)\n    RobertsonGraph           = staticmethod(smallgraphs.RobertsonGraph)\n    SchlaefliGraph           = staticmethod(smallgraphs.SchlaefliGraph)\n    shortened_00_11_binary_Golay_code_graph = staticmethod(distance_regular.shortened_00_11_binary_Golay_code_graph)\n    shortened_000_111_extended_binary_Golay_code_graph = staticmethod(distance_regular.shortened_000_111_extended_binary_Golay_code_graph)\n    ShrikhandeGraph          = staticmethod(smallgraphs.ShrikhandeGraph)\n    SimsGewirtzGraph         = staticmethod(smallgraphs.SimsGewirtzGraph)\n    SousselierGraph          = staticmethod(smallgraphs.SousselierGraph)\n    SylvesterGraph           = staticmethod(smallgraphs.SylvesterGraph)\n    SzekeresSnarkGraph       = staticmethod(smallgraphs.SzekeresSnarkGraph)\n    ThomsenGraph             = staticmethod(smallgraphs.ThomsenGraph)\n    TietzeGraph              = staticmethod(smallgraphs.TietzeGraph)\n    Tutte12Cage              = staticmethod(smallgraphs.Tutte12Cage)\n    TruncatedIcosidodecahedralGraph = staticmethod(smallgraphs.TruncatedIcosidodecahedralGraph)\n    TruncatedTetrahedralGraph = staticmethod(smallgraphs.TruncatedTetrahedralGraph)\n    TruncatedWittGraph       = staticmethod(distance_regular.TruncatedWittGraph)\n    TutteCoxeterGraph        = staticmethod(smallgraphs.TutteCoxeterGraph)\n    TutteGraph               = staticmethod(smallgraphs.TutteGraph)\n    U42Graph216              = staticmethod(smallgraphs.U42Graph216)\n    U42Graph540              = staticmethod(smallgraphs.U42Graph540)\n    WagnerGraph              = staticmethod(smallgraphs.WagnerGraph)\n    WatkinsSnarkGraph        = staticmethod(smallgraphs.WatkinsSnarkGraph)\n    WienerArayaGraph         = staticmethod(smallgraphs.WienerArayaGraph)\n    SuzukiGraph              = staticmethod(smallgraphs.SuzukiGraph)\n\n###########################################################################\n# Platonic Solids\n###########################################################################\n    from .generators import platonic_solids\n    DodecahedralGraph        = staticmethod(platonic_solids.DodecahedralGraph)\n    HexahedralGraph          = staticmethod(platonic_solids.HexahedralGraph)\n    IcosahedralGraph         = staticmethod(platonic_solids.IcosahedralGraph)\n    OctahedralGraph          = staticmethod(platonic_solids.OctahedralGraph)\n    TetrahedralGraph         = staticmethod(platonic_solids.TetrahedralGraph)\n\n###########################################################################\n# Families\n###########################################################################\n    from .generators import families\n    from . import strongly_regular_db\n    AlternatingFormsGraph   = staticmethod(distance_regular.AlternatingFormsGraph)\n    AztecDiamondGraph      = staticmethod(families.AztecDiamondGraph)\n    BalancedTree           = staticmethod(families.BalancedTree)\n    BarbellGraph           = staticmethod(families.BarbellGraph)\n    BilinearFormsGraph      = staticmethod(distance_regular.BilinearFormsGraph)\n    BubbleSortGraph        = staticmethod(families.BubbleSortGraph)\n    CaiFurerImmermanGraph  = staticmethod(families.CaiFurerImmermanGraph)\n    chang_graphs           = staticmethod(families.chang_graphs)\n    CirculantGraph         = staticmethod(families.CirculantGraph)\n    CubeGraph              = staticmethod(families.CubeGraph)\n    CubeConnectedCycle     = staticmethod(families.CubeConnectedCycle)\n    DipoleGraph            = staticmethod(families.DipoleGraph)\n    DorogovtsevGoltsevMendesGraph = staticmethod(families.DorogovtsevGoltsevMendesGraph)\n    DoubleGrassmannGraph   = staticmethod(distance_regular.DoubleGrassmannGraph)\n    DoubleOddGraph         = staticmethod(distance_regular.DoubleOddGraph)\n    EgawaGraph             = staticmethod(families.EgawaGraph)\n    FibonacciTree          = staticmethod(families.FibonacciTree)\n    FoldedCubeGraph        = staticmethod(families.FoldedCubeGraph)\n    FriendshipGraph        = staticmethod(families.FriendshipGraph)\n    FurerGadget            = staticmethod(families.FurerGadget)\n    FuzzyBallGraph         = staticmethod(families.FuzzyBallGraph)\n    GeneralizedPetersenGraph = staticmethod(families.GeneralizedPetersenGraph)\n    GoethalsSeidelGraph    = staticmethod(families.GoethalsSeidelGraph)\n    GrassmannGraph         = staticmethod(distance_regular.GrassmannGraph)\n    HalfCube               = staticmethod(distance_regular.HalfCube)\n    HammingGraph           = staticmethod(families.HammingGraph)\n    HanoiTowerGraph        = staticmethod(families.HanoiTowerGraph)\n    HararyGraph            = staticmethod(families.HararyGraph)\n    HermitianFormsGraph     = staticmethod(distance_regular.HermitianFormsGraph)\n    HyperStarGraph         = staticmethod(families.HyperStarGraph)\n    JohnsonGraph           = staticmethod(families.JohnsonGraph)\n    KneserGraph            = staticmethod(families.KneserGraph)\n    LCFGraph               = staticmethod(families.LCFGraph)\n    line_graph_forbidden_subgraphs = staticmethod(families.line_graph_forbidden_subgraphs)\n    LollipopGraph          = staticmethod(families.LollipopGraph)\n    MathonPseudocyclicMergingGraph = staticmethod(families.MathonPseudocyclicMergingGraph)\n    MathonPseudocyclicStronglyRegularGraph = staticmethod(families.MathonPseudocyclicStronglyRegularGraph)\n    MuzychukS6Graph        = staticmethod(families.MuzychukS6Graph)\n    MycielskiGraph         = staticmethod(families.MycielskiGraph)\n    MycielskiStep          = staticmethod(families.MycielskiStep)\n    NKStarGraph            = staticmethod(families.NKStarGraph)\n    NStarGraph             = staticmethod(families.NStarGraph)\n    OddGraph               = staticmethod(families.OddGraph)\n    PaleyGraph             = staticmethod(families.PaleyGraph)\n    PasechnikGraph         = staticmethod(families.PasechnikGraph)\n    petersen_family        = staticmethod(families.petersen_family)\n    RingedTree             = staticmethod(families.RingedTree)\n    SierpinskiGasketGraph  = staticmethod(families.SierpinskiGasketGraph)\n    SquaredSkewHadamardMatrixGraph = staticmethod(families.SquaredSkewHadamardMatrixGraph)\n    SwitchedSquaredSkewHadamardMatrixGraph = staticmethod(families.SwitchedSquaredSkewHadamardMatrixGraph)\n    strongly_regular_graph = staticmethod(strongly_regular_db.strongly_regular_graph)\n    TadpoleGraph           = staticmethod(families.TadpoleGraph)\n    trees                  = staticmethod(families.trees)\n    TuranGraph             = staticmethod(families.TuranGraph)\n    UstimenkoGraph         = staticmethod(distance_regular.UstimenkoGraph)\n    WheelGraph             = staticmethod(families.WheelGraph)\n    WindmillGraph          = staticmethod(families.WindmillGraph)\n\n###########################################################################\n# Graphs from classical geometries over `F_q`\n###########################################################################\n    from .generators import classical_geometries\n    AffineOrthogonalPolarGraph = staticmethod(classical_geometries.AffineOrthogonalPolarGraph)\n    AhrensSzekeresGeneralizedQuadrangleGraph = staticmethod(classical_geometries.AhrensSzekeresGeneralizedQuadrangleGraph)\n    NonisotropicOrthogonalPolarGraph = staticmethod(classical_geometries.NonisotropicOrthogonalPolarGraph)\n    NonisotropicUnitaryPolarGraph = staticmethod(classical_geometries.NonisotropicUnitaryPolarGraph)\n    OrthogonalDualPolarGraph = staticmethod(classical_geometries.OrthogonalDualPolarGraph)\n    OrthogonalPolarGraph = staticmethod(classical_geometries.OrthogonalPolarGraph)\n    SymplecticDualPolarGraph = staticmethod(classical_geometries.SymplecticDualPolarGraph)\n    SymplecticPolarGraph = staticmethod(classical_geometries.SymplecticPolarGraph)\n    TaylorTwographDescendantSRG = \\\n             staticmethod(classical_geometries.TaylorTwographDescendantSRG)\n    TaylorTwographSRG = staticmethod(classical_geometries.TaylorTwographSRG)\n    T2starGeneralizedQuadrangleGraph = staticmethod(classical_geometries.T2starGeneralizedQuadrangleGraph)\n    Nowhere0WordsTwoWeightCodeGraph = staticmethod(classical_geometries.Nowhere0WordsTwoWeightCodeGraph)\n    HaemersGraph = staticmethod(classical_geometries.HaemersGraph)\n    CossidentePenttilaGraph = staticmethod(classical_geometries.CossidentePenttilaGraph)\n    UnitaryDualPolarGraph = staticmethod(classical_geometries.UnitaryDualPolarGraph)\n    UnitaryPolarGraph = staticmethod(classical_geometries.UnitaryPolarGraph)\n\n###########################################################################\n# Chessboard Graphs\n###########################################################################\n    from .generators import chessboard\n    ChessboardGraphGenerator = staticmethod(chessboard.ChessboardGraphGenerator)\n    BishopGraph              = staticmethod(chessboard.BishopGraph)\n    KingGraph                = staticmethod(chessboard.KingGraph)\n    KnightGraph              = staticmethod(chessboard.KnightGraph)\n    QueenGraph               = staticmethod(chessboard.QueenGraph)\n    RookGraph                = staticmethod(chessboard.RookGraph)\n\n###########################################################################\n# Intersection graphs\n###########################################################################\n    from .generators import intersection\n    IntervalGraph            = staticmethod(intersection.IntervalGraph)\n    IntersectionGraph        = staticmethod(intersection.IntersectionGraph)\n    PermutationGraph         = staticmethod(intersection.PermutationGraph)\n    OrthogonalArrayBlockGraph  = staticmethod(intersection.OrthogonalArrayBlockGraph)\n    ToleranceGraph           = staticmethod(intersection.ToleranceGraph)\n\n###########################################################################\n# Random Graphs\n###########################################################################\n    from .generators import random\n    RandomBarabasiAlbert     = staticmethod(random.RandomBarabasiAlbert)\n    RandomBipartite          = staticmethod(random.RandomBipartite)\n    RandomRegularBipartite   = staticmethod(random.RandomRegularBipartite)\n    RandomBicubicPlanar      = staticmethod(random.RandomBicubicPlanar)\n    RandomBlockGraph         = staticmethod(random.RandomBlockGraph)\n    RandomBoundedToleranceGraph = staticmethod(random.RandomBoundedToleranceGraph)\n    RandomChordalGraph       = staticmethod(random.RandomChordalGraph)\n    RandomGNM                = staticmethod(random.RandomGNM)\n    RandomGNP                = staticmethod(random.RandomGNP)\n    RandomHolmeKim           = staticmethod(random.RandomHolmeKim)\n    RandomIntervalGraph      = staticmethod(random.RandomIntervalGraph)\n    RandomLobster            = staticmethod(random.RandomLobster)\n    RandomNewmanWattsStrogatz = staticmethod(random.RandomNewmanWattsStrogatz)\n    RandomRegular            = staticmethod(random.RandomRegular)\n    RandomShell              = staticmethod(random.RandomShell)\n    RandomToleranceGraph     = staticmethod(random.RandomToleranceGraph)\n    RandomTreePowerlaw       = staticmethod(random.RandomTreePowerlaw)\n    RandomTree               = staticmethod(random.RandomTree)\n    RandomTriangulation      = staticmethod(random.RandomTriangulation)\n\n###########################################################################\n# Maps\n###########################################################################\n    from .generators import world_map\n    WorldMap = staticmethod(world_map.WorldMap)\n    EuropeMap = staticmethod(world_map.EuropeMap)\n    AfricaMap = staticmethod(world_map.AfricaMap)\n    USAMap = staticmethod(world_map.USAMap)\n\n###########################################################################\n# Degree Sequence\n###########################################################################\n    from .generators import degree_sequence\n    DegreeSequence           = staticmethod(degree_sequence.DegreeSequence)\n    DegreeSequenceBipartite  = staticmethod(degree_sequence.DegreeSequenceBipartite)\n    DegreeSequenceConfigurationModel = staticmethod(degree_sequence.DegreeSequenceConfigurationModel)\n    DegreeSequenceTree       = staticmethod(degree_sequence.DegreeSequenceTree)\n    DegreeSequenceExpected   = staticmethod(degree_sequence.DegreeSequenceExpected)\n\ndef canaug_traverse_vert(g, aut_gens, max_verts, property, dig=False, loops=False, sparse=True):\n    \"\"\"\n    Main function for exhaustive generation. Recursive traversal of a\n    canonically generated tree of isomorph free (di)graphs satisfying a\n    given property.\n\n    INPUT:\n\n\n    -  ``g`` - current position on the tree.\n\n    -  ``aut_gens`` - list of generators of Aut(g), in\n       list notation.\n\n    -  ``max_verts`` - when to retreat.\n\n    -  ``property`` - check before traversing below g.\n\n    -  ``degree_sequence`` - specify a degree sequence to try to\n       obtain.\n\n\n    EXAMPLES::\n\n        sage: from sage.graphs.graph_generators import canaug_traverse_vert\n        sage: list(canaug_traverse_vert(Graph(), [], 3, lambda x: True))\n        [Graph on 0 vertices, ... Graph on 3 vertices]\n\n    The best way to access this function is through the graphs()\n    iterator:\n\n    Print graphs on 3 or less vertices.\n\n    ::\n\n        sage: for G in graphs(3, augment='vertices'):\n        ....:    print(G)\n        Graph on 0 vertices\n        Graph on 1 vertex\n        Graph on 2 vertices\n        Graph on 3 vertices\n        Graph on 3 vertices\n        Graph on 3 vertices\n        Graph on 2 vertices\n        Graph on 3 vertices\n\n    Print digraphs on 2 or less vertices.\n\n    ::\n\n        sage: for D in digraphs(2, augment='vertices'):\n        ....:     print(D)\n        Digraph on 0 vertices\n        Digraph on 1 vertex\n        Digraph on 2 vertices\n        Digraph on 2 vertices\n        Digraph on 2 vertices\n    \"\"\"\n    from sage.groups.perm_gps.partn_ref.refinement_graphs import search_tree\n    if not property(g):\n        return\n    yield g\n\n    n = g.order()\n    if n < max_verts:\n\n        # build a list representing C(g) - the vertex to be added\n        # is at the end, so only specify which edges...\n        # in the case of graphs, there are n possibilities,\n        # and in the case of digraphs, there are 2*n.\n        if dig:\n            possibilities = 2*n\n        else:\n            possibilities = n\n        num_roots = 2**possibilities\n        children = [-1]*num_roots\n\n        # union-find C(g) under Aut(g)\n        for gen in aut_gens:\n            for i in range(len(children)):\n                k = 0\n                for j in range(possibilities):\n                    if (1 << j)&i:\n                        if dig and j >= n:\n                            k += (1 << (gen[j-n]+n))\n                        else:\n                            k += (1 << gen[j])\n                while children[k] != -1:\n                    k = children[k]\n                while children[i] != -1:\n                    i = children[i]\n                if i != k:\n                    # union i & k\n                    smaller, larger = sorted([i,k])\n                    children[larger] = smaller\n                    num_roots -= 1\n\n        # find representatives of orbits of C(g)\n        roots = []\n        found_roots = 0\n        i = 0\n        while found_roots < num_roots:\n            if children[i] == -1:\n                found_roots += 1\n                roots.append(i)\n            i += 1\n        for i in roots:\n            # construct a z for each number in roots...\n            z = g.copy(sparse=sparse)\n            z.add_vertex(n)\n            edges = []\n            if dig:\n                index = 0\n                while 2 * index < possibilities:\n                    if (1 << index)&i:\n                        edges.append((index,n))\n                    index += 1\n                while index < possibilities:\n                    if (1 << index)&i:\n                        edges.append((n,index-n))\n                    index += 1\n            else:\n                index = 0\n                while (1 << index) <= i:\n                    if (1 << index)&i:\n                        edges.append((index,n))\n                    index += 1\n            z.add_edges(edges)\n            z_s = []\n            if property(z):\n                z_s.append(z)\n            if loops:\n                z = z.copy(sparse=sparse)\n                z.add_edge((n,n))\n                if property(z):\n                    z_s.append(z)\n            for z in z_s:\n                z_aut_gens, _, canonical_relabeling = search_tree(z, [z.vertices()], certificate=True, dig=(dig or loops))\n                cut_vert = 0\n                while canonical_relabeling[cut_vert] != n:\n                    cut_vert += 1\n                sub_verts = [v for v in z if v != cut_vert]\n                m_z = z.subgraph(sub_verts)\n\n                if m_z == g:\n                    for a in canaug_traverse_vert(z, z_aut_gens, max_verts, property, dig=dig, loops=loops, sparse=sparse):\n                        yield a\n                else:\n                    for possibility in check_aut(z_aut_gens, cut_vert, n):\n                        if m_z.relabel(dict(enumerate(possibility)), check_input=False, inplace=False) == g:\n                            for a in canaug_traverse_vert(z, z_aut_gens, max_verts, property, dig=dig, loops=loops, sparse=sparse):\n                                yield a\n                            break\n\ndef check_aut(aut_gens, cut_vert, n):\n    \"\"\"\n    Helper function for exhaustive generation.\n\n    At the start, check_aut is given a set of generators for the\n    automorphism group, aut_gens. We already know we are looking for\n    an element of the auto- morphism group that sends cut_vert to n,\n    and check_aut generates these for the canaug_traverse function.\n\n    EXAMPLES:\n\n    Note that the last two entries indicate that none of the\n    automorphism group has yet been searched - we are starting at the\n    identity [0, 1, 2, 3] and so far that is all we have seen. We\n    return automorphisms mapping 2 to 3::\n\n        sage: from sage.graphs.graph_generators import check_aut\n        sage: list( check_aut( [ [0, 3, 2, 1], [1, 0, 3, 2], [2, 1, 0, 3] ], 2, 3))\n        [[1, 0, 3, 2], [1, 2, 3, 0]]\n    \"\"\"\n    from copy import copy\n    perm = list(range(n + 1))\n    seen_perms = [perm]\n    unchecked_perms = [perm]\n    while unchecked_perms:\n        perm = unchecked_perms.pop(0)\n        for gen in aut_gens:\n            new_perm = copy(perm)\n            for i in range(len(perm)):\n                new_perm[i] = gen[perm[i]]\n            if new_perm not in seen_perms:\n                seen_perms.append(new_perm)\n                unchecked_perms.append(new_perm)\n                if new_perm[cut_vert] == n:\n                    yield new_perm\n\n\ndef canaug_traverse_edge(g, aut_gens, property, dig=False, loops=False, sparse=True):\n    \"\"\"\n    Main function for exhaustive generation. Recursive traversal of a\n    canonically generated tree of isomorph free graphs satisfying a\n    given property.\n\n    INPUT:\n\n\n    -  ``g`` - current position on the tree.\n\n    -  ``aut_gens`` - list of generators of Aut(g), in\n       list notation.\n\n    -  ``property`` - check before traversing below g.\n\n\n    EXAMPLES::\n\n        sage: from sage.graphs.graph_generators import canaug_traverse_edge\n        sage: G = Graph(3)\n        sage: list(canaug_traverse_edge(G, [], lambda x: True))\n        [Graph on 3 vertices, ... Graph on 3 vertices]\n\n    The best way to access this function is through the graphs()\n    iterator:\n\n    Print graphs on 3 or less vertices.\n\n    ::\n\n        sage: for G in graphs(3):\n        ....:     print(G)\n        Graph on 3 vertices\n        Graph on 3 vertices\n        Graph on 3 vertices\n        Graph on 3 vertices\n\n    Print digraphs on 3 or less vertices.\n\n    ::\n\n        sage: for G in digraphs(3):\n        ....:     print(G)\n        Digraph on 3 vertices\n        Digraph on 3 vertices\n        ...\n        Digraph on 3 vertices\n        Digraph on 3 vertices\n    \"\"\"\n    from sage.groups.perm_gps.partn_ref.refinement_graphs import search_tree\n\n    if not property(g):\n        return\n    yield g\n    n = g.order()\n    if dig:\n        max_size = n*(n-1)\n    else:\n        max_size = (n*(n-1))>>1 # >> 1 is just / 2 (this is n choose 2)\n    if loops:\n        max_size += n\n    if g.size() < max_size:\n        # build a list representing C(g) - the edge to be added\n        # is one of max_size choices\n        if dig:\n            children = [[(j,i) for i in range(n)] for j in range(n)]\n        else:\n            children = [[(j,i) for i in range(j)] for j in range(n)]\n        # union-find C(g) under Aut(g)\n        orbits = list(range(n))\n        for gen in aut_gens:\n            for iii in range(n):\n                if orbits[gen[iii]] != orbits[iii]:\n                    temp = orbits[gen[iii]]\n                    for jjj in range(n):\n                        if orbits[jjj] == temp:\n                            orbits[jjj] = orbits[iii]\n                if dig:\n                    jjj_range = list(range(iii)) + list(range(iii + 1, n))\n                else:\n                    jjj_range = list(range(iii))  # iii > jjj\n                for jjj in jjj_range:\n                    i, j = iii, jjj\n                    if dig:\n                        x, y = gen[i], gen[j]\n                    else:\n                        y, x = sorted([gen[i], gen[j]])\n                    if children[i][j] != children[x][y]:\n                        x_val, y_val = x, y\n                        i_val, j_val = i, j\n                        if dig:\n                            while (x_val, y_val) != children[x_val][y_val]:\n                                x_val, y_val = children[x_val][y_val]\n                            while (i_val, j_val) != children[i_val][j_val]:\n                                i_val, j_val = children[i_val][j_val]\n                        else:\n                            while (x_val, y_val) != children[x_val][y_val]:\n                                y_val, x_val = sorted(children[x_val][y_val])\n                            while (i_val, j_val) != children[i_val][j_val]:\n                                j_val, i_val = sorted(children[i_val][j_val])\n                        while (x, y) != (x_val, y_val):\n                            xx, yy = x, y\n                            x, y = children[x][y]\n                            children[xx][yy] = (x_val, y_val)\n                        while (i, j) != (i_val, j_val):\n                            ii, jj = i, j\n                            i, j = children[i][j]\n                            children[ii][jj] = (i_val, j_val)\n                        if x < i:\n                            children[i][j] = (x, y)\n                        elif x > i:\n                            children[x][y] = (i, j)\n                        elif y < j:\n                            children[i][j] = (x, y)\n                        elif y > j:\n                            children[x][y] = (i, j)\n                        else:\n                            continue\n        # find representatives of orbits of C(g)\n        roots = []\n        for i in range(n):\n            if dig:\n                j_range = list(range(i)) + list(range(i + 1, n))\n            else:\n                j_range = list(range(i))\n            for j in j_range:\n                if children[i][j] == (i, j):\n                    roots.append((i,j))\n        if loops:\n            seen = []\n            for i in range(n):\n                if orbits[i] not in seen:\n                    roots.append((i,i))\n                    seen.append(orbits[i])\n        for i, j in roots:\n            if g.has_edge(i, j):\n                continue\n            # construct a z for each edge in roots...\n            z = g.copy(sparse=sparse)\n            z.add_edge(i, j)\n            if not property(z):\n                continue\n            z_aut_gens, _, canonical_relabeling = search_tree(z, [z.vertices()], certificate=True, dig=(dig or loops))\n            relabel_inverse = [0]*n\n            for ii in range(n):\n                relabel_inverse[canonical_relabeling[ii]] = ii\n            z_can = z.relabel(canonical_relabeling, inplace=False)\n            cut_edge_can = z_can.edges(labels=False, sort=True)[-1]\n            cut_edge = [relabel_inverse[cut_edge_can[0]], relabel_inverse[cut_edge_can[1]]]\n            if dig:\n                cut_edge = tuple(cut_edge)\n            else:\n                cut_edge = tuple(sorted(cut_edge))\n\n            from copy import copy\n            m_z = copy(z)\n            m_z.delete_edge(cut_edge)\n            if m_z == g:\n                for a in canaug_traverse_edge(z, z_aut_gens, property, dig=dig, loops=loops, sparse=sparse):\n                    yield a\n            else:\n                for possibility in check_aut_edge(z_aut_gens, cut_edge, i, j, n, dig=dig):\n                    if m_z.relabel(possibility, inplace=False) == g:\n                        for a in canaug_traverse_edge(z, z_aut_gens, property, dig=dig, loops=loops, sparse=sparse):\n                            yield a\n                        break\n\ndef check_aut_edge(aut_gens, cut_edge, i, j, n, dig=False):\n    \"\"\"\n    Helper function for exhaustive generation.\n\n    At the start, check_aut_edge is given a set of generators for the\n    automorphism group, aut_gens. We already know we are looking for\n    an element of the auto- morphism group that sends cut_edge to {i,\n    j}, and check_aut generates these for the canaug_traverse\n    function.\n\n    EXAMPLES:\n\n    Note that the last two entries indicate that none of the\n    automorphism group has yet been searched - we are starting at the\n    identity [0, 1, 2, 3] and so far that is all we have seen. We\n    return automorphisms mapping 2 to 3::\n\n        sage: from sage.graphs.graph_generators import check_aut\n        sage: list( check_aut( [ [0, 3, 2, 1], [1, 0, 3, 2], [2, 1, 0, 3] ], 2, 3))\n        [[1, 0, 3, 2], [1, 2, 3, 0]]\n    \"\"\"\n    from copy import copy\n    perm = list(range(n))\n    seen_perms = [perm]\n    unchecked_perms = [perm]\n    while unchecked_perms:\n        perm = unchecked_perms.pop(0)\n        for gen in aut_gens:\n            new_perm = copy(perm)\n            for ii in range(n):\n                new_perm[ii] = gen[perm[ii]]\n            if new_perm not in seen_perms:\n                seen_perms.append(new_perm)\n                unchecked_perms.append(new_perm)\n                if new_perm[cut_edge[0]] == i and new_perm[cut_edge[1]] == j:\n                    yield new_perm\n                if not dig and new_perm[cut_edge[0]] == j and new_perm[cut_edge[1]] == i:\n                    yield new_perm\n\n# Easy access to the graph generators from the command line:\ngraphs = GraphGenerators()\n", "meta": {"hexsha": "0aebc8e1709cad157db2f737e8c8f658247589a4", "size": 103398, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/graphs/graph_generators.py", "max_stars_repo_name": "bollu/sage", "max_stars_repo_head_hexsha": "1da6df404d3ea7ff3019e16ea50d65923c1f4ece", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-11-12T04:06:19.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-12T04:06:19.000Z", "max_issues_repo_path": "src/sage/graphs/graph_generators.py", "max_issues_repo_name": "tamnguyen135/sage", "max_issues_repo_head_hexsha": "2c87dc16f26604033bb1b2d1dc6796d279c88b16", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-04-18T16:30:43.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-18T16:30:43.000Z", "max_forks_repo_path": "src/sage/graphs/graph_generators.py", "max_forks_repo_name": "dimpase/sage", "max_forks_repo_head_hexsha": "468f23815ade42a2192b0a9cd378de8fdc594dcd", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.6921305182, "max_line_length": 146, "alphanum_fraction": 0.5936285035, "include": true, "reason": "from sage", "num_tokens": 24684, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.39233684437737093, "lm_q2_score": 0.1732882059293266, "lm_q1q2_score": 0.06798734788212801}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Training Deep Neural Networks on a GPU with PyTorch\n# \n# ### Part 4 of \"Deep Learning with Pytorch: Zero to GANs\"\n# \n# This tutorial series is a hands-on beginner-friendly introduction to deep learning using [PyTorch](https://pytorch.org), an open-source neural networks library. These tutorials take a practical and coding-focused approach. The best way to learn the material is to execute the code and experiment with it yourself. Check out the full series here:\n# \n# 1. [PyTorch Basics: Tensors & Gradients](https://jovian.ai/aakashns/01-pytorch-basics)\n# 2. [Gradient Descent & Linear Regression](https://jovian.ai/aakashns/02-linear-regression)\n# 3. [Working with Images & Logistic Regression](https://jovian.ai/aakashns/03-logistic-regression) \n# 4. [Training Deep Neural Networks on a GPU](https://jovian.ai/aakashns/04-feedforward-nn)\n# 5. [Image Classification using Convolutional Neural Networks](https://jovian.ai/aakashns/05-cifar10-cnn)\n# 6. [Data Augmentation, Regularization and ResNets](https://jovian.ai/aakashns/05b-cifar10-resnet)\n# 7. [Generating Images using Generative Adversarial Networks](https://jovian.ai/aakashns/06b-anime-dcgan/)\n# \n\n#  This tutorial covers the following topics:\n#  \n#  * Creating a deep neural network with hidden layers\n#  * Using a non-linear activation function\n#  * Using a GPU (when available) to speed up training\n#  * Experimenting with hyperparameters to improve the model\n\n# ### How to run the code\n# \n# This tutorial is an executable [Jupyter notebook](https://jupyter.org) hosted on [Jovian](https://www.jovian.ai). You can _run_ this tutorial and experiment with the code examples in a couple of ways: *using free online resources* (recommended) or *on your computer*.\n# \n# #### Option 1: Running using free online resources (1-click, recommended)\n# \n# The easiest way to start executing the code is to click the **Run** button at the top of this page and select **Run on Colab**. [Google Colab](https://colab.research.google.com) is a free online platform for running Jupyter notebooks using Google's cloud infrastructure. You can also select \"Run on Binder\" or \"Run on Kaggle\" if you face issues running the notebook on Google Colab. \n# \n# \n# #### Option 2: Running on your computer locally\n# \n# To run the code on your computer locally, you'll need to set up [Python](https://www.python.org), download the notebook and install the required libraries. We recommend using the [Conda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/) distribution of Python. Click the **Run** button at the top of this page, select the **Run Locally** option, and follow the instructions.\n# \n# >  **Jupyter Notebooks**: This tutorial is a [Jupyter notebook](https://jupyter.org) - a document made of _cells_. Each cell can contain code written in Python or explanations in plain English. You can execute code cells and view the results, e.g., numbers, messages, graphs, tables, files, etc., instantly within the notebook. Jupyter is a powerful platform for experimentation and analysis. Don't be afraid to mess around with the code & break things - you'll learn a lot by encountering and fixing errors. You can use the \"Kernel > Restart & Clear Output\" or \"Edit > Clear Outputs\" menu option to clear all outputs and start again from the top.\n\n# ### Using a GPU for faster training\n# \n# You can use a [Graphics Processing Unit](https://en.wikipedia.org/wiki/Graphics_processing_unit) (GPU) to train your models faster if your execution platform is connected to a GPU manufactured by NVIDIA. Follow these instructions to use a GPU on the platform of your choice:\n# \n# * _Google Colab_: Use the menu option \"Runtime > Change Runtime Type\" and select \"GPU\" from the \"Hardware Accelerator\" dropdown.\n# * _Kaggle_: In the \"Settings\" section of the sidebar, select \"GPU\" from the \"Accelerator\" dropdown. Use the button on the top-right to open the sidebar.\n# * _Binder_: Notebooks running on Binder cannot use a GPU, as the machines powering Binder aren't connected to any GPUs.\n# * _Linux_: If your laptop/desktop has an NVIDIA GPU (graphics card), make sure you have installed the [NVIDIA CUDA drivers](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html).\n# * _Windows_: If your laptop/desktop has an NVIDIA GPU (graphics card), make sure you have installed the [NVIDIA CUDA drivers](https://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html).\n# * _macOS_: macOS is not compatible with NVIDIA GPUs\n# \n# \n# If you do not have access to a GPU or aren't sure what it is, don't worry, you can execute all the code in this tutorial just fine without a GPU.\n\n# ## Preparing the Data\n# \n# In [the previous tutorial](https://jovian.ai/aakashns/03-logistic-regression), we trained a logistic regression model to identify handwritten digits from the MNIST dataset with an accuracy of around 86%. The dataset consists of 28px by 28px grayscale images of handwritten digits (0 to 9) and labels for each image indicating which digit it represents. Here are some sample images from the dataset:\n# \n# ![mnist-sample](https://i.imgur.com/CAYnuo1.jpg)\n# \n# We noticed that it's quite challenging to improve the accuracy of a logistic regression model beyond 87%, since the model assumes a linear relationship between pixel intensities and image labels. In this post, we'll try to improve upon it  using a *feed-forward neural network* which can capture non-linear relationships between inputs and targets.\n# \n# Let's begin by installing and importing the required modules and classes from `torch`, `torchvision`, `numpy`, and `matplotlib`.\n\n# In[1]:\n\n\n# Uncomment and run the appropriate command for your operating system, if required\n\n# Linux / Binder\n# !pip install numpy matplotlib torch==1.7.0+cpu torchvision==0.8.1+cpu torchaudio==0.7.0 -f https://download.pytorch.org/whl/torch_stable.html\n\n# MacOS\n# !pip install numpy matplotlib torch torchvision torchaudio\n\n\n# In[2]:\n\n\nimport torch\nimport torchvision\nimport numpy as np\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torchvision.datasets import MNIST\nfrom torchvision.transforms import ToTensor\nfrom torchvision.utils import make_grid\nfrom torch.utils.data.dataloader import DataLoader\nfrom torch.utils.data import random_split\n\n# Use a white background for matplotlib figures\nmatplotlib.rcParams['figure.facecolor'] = '#ffffff'\n\n\n# We can download the data and create a PyTorch dataset using the `MNIST` class from `torchvision.datasets`. \n\n# In[3]:\n\n\ndataset = MNIST(root='data/', download=True, transform=ToTensor())\n\n\n# Let's look at a couple of images from the dataset. The images are converted to PyTorch tensors with the shape `1x28x28` (the dimensions represent color channels, width and height). We can use `plt.imshow` to display the images. However, `plt.imshow` expects channels to be last dimension in an image tensor, so we use the `permute` method to reorder the dimensions of the image.\n\n# In[4]:\n\n\nimage, label = dataset[0]\nprint('image.shape:', image.shape)\nimage_perm = image.permute(1, 2, 0)\nprint(image_perm.shape)\nplt.imshow(image[0], cmap='gray')\nprint('Label:', label)\n\n\n# In[5]:\n\n\nimage, label = dataset[0]\nprint('image.shape:', image.shape)\nplt.imshow(image[0], cmap='gray')\nprint('Label:', label)\n\n\n# Next, let's use the `random_split` helper function to set aside 10000 images for our validation set.\n\n# In[6]:\n\n\nval_size = 10000\ntrain_size = len(dataset) - val_size\n\ntrain_ds, val_ds = random_split(dataset, [train_size, val_size])\nlen(train_ds), len(val_ds)\n\n\n# We can now create PyTorch data loaders for training and validation.\n\n# In[7]:\n\n\nbatch_size=128\n\n\n# In[8]:\n\n\ntrain_loader = DataLoader(train_ds, batch_size, shuffle=True, num_workers=4, pin_memory=True)\nval_loader = DataLoader(val_ds, batch_size*2, num_workers=4, pin_memory=True)\n\nprint(torch.cuda.device_count())\n\n\n# Can you figure out the purpose of the arguments `num_workers` and `pin_memory`? Try looking into the documentation: https://pytorch.org/docs/stable/data.html .\n# \n# Let's visualize a batch of data in a grid using the `make_grid` function from `torchvision`. We'll also use the `.permute` method on the tensor to move the channels to the last dimension, as expected by `matplotlib`.\n\n# In[9]:\n\n\nfor images, _ in train_loader:\n    print('images.shape:', images.shape)\n    plt.figure(figsize=(16,8))\n    plt.axis('off')\n    plt.imshow(make_grid(images, nrow=16).permute((1, 2, 0)))\n    break\n\n\n# ## Hidden Layers, Activation Functions and Non-Linearity\n# \n# We'll create a neural network with two layers: a _hidden layer_ and an _output layer_. Additionally, we'll use an _activation function_ between the two layers. Let's look at a step-by-step example to learn how hidden layers and activation functions can help capture non-linear relationships between inputs and outputs.\n# \n# First, let's create a batch of inputs tensors. We'll flatten the `1x28x28` images into vectors of size `784`, so they can be passed into an `nn.Linear` object.\n\n# In[11]:\n\n\nfor images, labels in train_loader:\n    print('images.shape:', images.shape)\n    inputs = images.reshape(-1, 784)\n    print('inputs.shape:', inputs.shape)\n    break\n\n\n# Next, let's create a `nn.Linear` object, which will serve as our _hidden_ layer. We'll set the size of the output from the hidden layer to 32. This number can be increased or decreased to change the _learning capacity_ of the model.\n\n# In[59]:\n\n\ninput_size = inputs.shape[-1]\nhidden_size = 256\n\n\n# In[60]:\n\n\nlayer1 = nn.Linear(input_size, hidden_size)\n\n\n# We can now compute intermediate outputs for the batch of images by passing `inputs` through `layer1`.\n\n# In[61]:\n\n\ninputs.shape\n\n\n# In[62]:\n\n\nlayer1_outputs = layer1(inputs)\nprint('layer1_outputs.shape:', layer1_outputs.shape)\n\n\n# The image vectors of size `784` are transformed into intermediate output vectors of length `32` by performing a matrix multiplication of `inputs` matrix with the transposed weights matrix of `layer1` and adding the bias. We can verify this using `torch.allclose`. For a more detailed explanation, review the tutorial on [linear regression](https://jovian.ai/aakashns/02-linear-regression).\n\n# In[63]:\n\n\nlayer1_outputs_direct = inputs @ layer1.weight.t() + layer1.bias\nlayer1_outputs_direct.shape\n\n\n# In[64]:\n\n\ntorch.allclose(layer1_outputs, layer1_outputs_direct, 1e-3)\n\n\n# Thus, `layer1_outputs` and `inputs` have a linear relationship, i.e., each element of `layer_outputs` is a weighted sum of elements from `inputs`. Thus, even as we train the model and modify the weights, `layer1` can only capture linear relationships between `inputs` and `outputs`.\n# \n# <img src=\"https://i.imgur.com/inXsLuq.png\" width=\"360\">\n# \n\n# Next, we'll use the Rectified Linear Unit (ReLU) function as the activation function for the outputs. It has the formula `relu(x) = max(0,x)` i.e. it simply replaces negative values in a given tensor with the value 0. ReLU is a non-linear function, as seen here visually:\n# \n# <img src=\"https://i.imgur.com/yijV4xF.png\" width=\"420\">\n# \n# We can use the `F.relu` method to apply ReLU to the elements of a tensor.\n\n# In[65]:\n\n\nF.relu(torch.tensor([[1, -1, 0], \n                     [-0.1, .2, 3]]))\n\n\n# Let's apply the activation function to `layer1_outputs` and verify that negative values were replaced with 0.\n\n# In[66]:\n\n\nrelu_outputs = F.relu(layer1_outputs)\nprint('min(layer1_outputs):', torch.min(layer1_outputs).item())\nprint('min(relu_outputs):', torch.min(relu_outputs).item())\n\n\n# Now that we've applied a non-linear activation function, `relu_outputs` and `inputs` do not have a linear relationship. We refer to `ReLU` as the _activation function_, because for each input certain outputs are activated (those with non-zero values) while others turned off (those with zero values)\n# \n# Next, let's create an output layer to convert vectors of length `hidden_size` in `relu_outputs` into vectors of length 10, which is the desired output of our model (since there are 10 target labels).\n\n# In[67]:\n\n\noutput_size = 10\nlayer2 = nn.Linear(hidden_size, output_size)\n\n\n# In[68]:\n\n\nlayer2_outputs = layer2(relu_outputs)\nprint(layer2_outputs.shape)\n\n\n# In[69]:\n\n\ninputs.shape\n\n\n# As expected, `layer2_outputs` contains a batch of vectors of size 10. We can now use this output to compute the loss using `F.cross_entropy` and adjust the weights of `layer1` and `layer2` using gradient descent.\n\n# In[70]:\n\n\nF.cross_entropy(layer2_outputs, labels)\n\n\n# Thus, our model transforms `inputs` into `layer2_outputs` by applying a linear transformation (using `layer1`), followed by a non-linear activation (using `F.relu`), followed by another linear transformation (using `layer2`). Let's verify this by re-computing the output using basic matrix operations.\n\n# In[71]:\n\n\n# Expanded version of layer2(F.relu(layer1(inputs)))\noutputs = (F.relu(inputs @ layer1.weight.t() + layer1.bias)) @ layer2.weight.t() + layer2.bias\n\n\n# In[72]:\n\n\ntorch.allclose(outputs, layer2_outputs, 1e-3)\n\n\n# Note that `outputs` and `inputs` do not have a linear relationship due to the non-linear activation function `F.relu`. As we train the model and adjust the weights of `layer1` and `layer2`, we can now capture non-linear relationships between the images and their labels. In other words, introducing non-linearity makes the model more powerful and versatile. Also, since `hidden_size` does not depend on the dimensions of the inputs or outputs, we vary it to increase the number of parameters within the model. We can also introduce new hidden layers and apply the same non-linear activation after each hidden layer.\n# \n# The model we just created is called a neural network. A _deep neural network_ is simply a neural network with one or more hidden layers. In fact, the [Universal Approximation Theorem](http://neuralnetworksanddeeplearning.com/chap4.html) states that a sufficiently large & deep neural network can compute any arbitrary function i.e. it can _learn_ rich and complex non-linear relationships between inputs and targets. Here are some examples:\n# \n# * Identifying if an image contains a cat or a dog (or [something else](https://machinelearningmastery.com/introduction-to-the-imagenet-large-scale-visual-recognition-challenge-ilsvrc/))\n# * Identifying the genre of a song using a 10-second sample\n# * Classifying movie reviews as positive or negative based on their content\n# * Navigating self-driving cars using a video feed of the road\n# * Translating sentences from English to French (and hundreds of other languages)\n# * Converting a speech recording to text and vice versa\n# * And many more...\n# \n# It's hard to imagine how the simple process of multiplying inputs with randomly initialized matrices, applying non-linear activations, and adjusting weights repeatedly using gradient descent can yield such astounding results. Deep learning models often contain millions of parameters, which can together capture far more complex relationships than the human brain can comprehend.\n# \n# If we hadn't included a non-linear activation between the two linear layers, the final relationship between inputs and outputs would still be linear. A simple refactoring of the computations illustrates this.\n\n# In[73]:\n\n\n# Same as layer2(layer1(inputs))\noutputs2 = (inputs @ layer1.weight.t() + layer1.bias) @ layer2.weight.t() + layer2.bias\n\n\n# In[74]:\n\n\n# Create a single layer to replace the two linear layers\ncombined_layer = nn.Linear(input_size, output_size)\n\ncombined_layer.weight.data = layer2.weight @ layer1.weight\ncombined_layer.bias.data = layer1.bias @ layer2.weight.t() + layer2.bias\n\n\n# In[75]:\n\n\n# Same as combined_layer(inputs)\noutputs3 = inputs @ combined_layer.weight.t() + combined_layer.bias\n\n\n# In[76]:\n\n\ntorch.allclose(outputs2, outputs3, 1e-3)\n\n\n# ### Save and upload your notebook\n# \n# Whether you're running this Jupyter notebook online or on your computer, it's essential to save your work from time to time. You can continue working on a saved notebook later or share it with friends and colleagues to let them execute your code. [Jovian](https://jovian.ai/platform-features) offers an easy way of saving and sharing your Jupyter notebooks online.\n\n# In[39]:\n\n\n# In[40]:\n\n# In[41]:\n\n# `jovian.commit` uploads the notebook to your Jovian account, captures the Python environment, and creates a shareable link for your notebook, as shown above. You can use this link to share your work and let anyone (including you) run your notebooks and reproduce your work.\n\n# ## Model\n# \n# We are now ready to define our model. As discussed above, we'll create a neural network with one hidden layer. Here's what that means:\n# \n# * Instead of using a single `nn.Linear` object to transform a batch of inputs (pixel intensities) into outputs (class probabilities), we'll use two `nn.Linear` objects. Each of these is called a _layer_ in the network. \n# \n# * The first layer (also known as the hidden layer) will transform the input matrix of shape `batch_size x 784` into an intermediate output matrix of shape `batch_size x hidden_size`. The parameter `hidden_size` can be configured manually (e.g., 32 or 64).\n# \n# * We'll then apply a non-linear *activation function* to the intermediate outputs. The activation function transforms individual elements of the matrix.\n# \n# * The result of the activation function, which is also of size `batch_size x hidden_size`, is passed into the second layer (also known as the output layer).  The second layer transforms it into a matrix of size `batch_size x 10`. We can use this output to compute the loss and adjust weights using gradient descent.\n# \n# \n# As discussed above, our model will contain one hidden layer. Here's what it looks like visually:\n# \n# <img src=\"https://i.imgur.com/eN7FrpF.png\" width=\"480\">\n# \n# \n# Let's define the model by extending the `nn.Module` class from PyTorch.\n\n# In[275]:\n\n\nclass MnistModel(nn.Module):\n    \"\"\"Feedfoward neural network with 1 hidden layer\"\"\"\n    def __init__(self, in_size, hidden_size, out_size):\n        super().__init__()\n        \n        self.hidden_count = 1\n        self.hidden_layers = []\n        \n       \n        # hidden layer\n        self.linear1 = nn.Linear(in_size, hidden_size)\n        # output layer\n        \n        for x in range(self.hidden_count) :\n           self.hidden_layers.append(nn.Linear(hidden_size, hidden_size));\n        \n        self.linear4 = nn.Linear(hidden_size, out_size)\n        \n    def forward(self, xb):\n        # Flatten the image tensors\n        xb = xb.view(xb.size(0), -1)\n        # Get intermediate outputs using hidden layer\n        out = self.linear1(xb)\n        # Apply activation function\n        out = F.relu(out)\n        \n        #for layer in self.hidden_layers:\n        #    out = layer(out)\n        #    out = F.relu(out)\n        \n        # Get predictions using output layer\n        out = self.linear4(out)\n        return out\n    \n    def training_step(self, batch):\n        images, labels = batch \n        out = self(images)                  # Generate predictions\n        loss = F.cross_entropy(out, labels) # Calculate loss\n        return loss\n    \n    def validation_step(self, batch):\n        images, labels = batch \n        out = self(images)                    # Generate predictions\n        loss = F.cross_entropy(out, labels)   # Calculate loss\n        acc = accuracy(out, labels)           # Calculate accuracy\n        return {'val_loss': loss, 'val_acc': acc}\n        \n    def validation_epoch_end(self, outputs):\n        batch_losses = [x['val_loss'] for x in outputs]\n        epoch_loss = torch.stack(batch_losses).mean()   # Combine losses\n        batch_accs = [x['val_acc'] for x in outputs]\n        epoch_acc = torch.stack(batch_accs).mean()      # Combine accuracies\n        return {'val_loss': epoch_loss.item(), 'val_acc': epoch_acc.item()}\n    \n    def epoch_end(self, epoch, result):\n        print(\"Epoch [{}], val_loss: {:.4f}, val_acc: {:.4f}\".format(epoch, result['val_loss'], result['val_acc']))\n\n\n# We also need to define an `accuracy` function which calculates the accuracy of the model's prediction on an batch of inputs. It's used in `validation_step` above.\n\n# In[276]:\n\n\ndef accuracy(outputs, labels):\n    _, preds = torch.max(outputs, dim=1)\n    return torch.tensor(torch.sum(preds == labels).item() / len(preds))\n\n\n# We'll create a model that contains a hidden layer with 32 activations.\n\n# In[277]:\n\n\ninput_size = 784\nhidden_size = 1024 # you can change this\nnum_classes = 10\n\n\n# In[278]:\n\n\nmodel = MnistModel(input_size, hidden_size=1024, out_size=num_classes)\n\n\n# Let's take a look at the model's parameters. We expect to see one weight and bias matrix for each of the layers.\n\n# In[279]:\n\n\nfor t in model.parameters():\n    print(t.shape)\n\n\n# Let's try and generate some outputs using our model. We'll take the first batch of 128 images from our dataset and pass them into our model.\n\n# In[280]:\n\n\nfor images, labels in train_loader:\n    outputs = model(images)\n    loss = F.cross_entropy(outputs, labels)\n    print('Loss:', loss.item())\n    break\n\nprint('outputs.shape : ', outputs.shape)\nprint('Sample outputs :\\n', outputs[:2].data)\n\n\n# ## Using a GPU\n# \n# As the sizes of our models and datasets increase, we need to use GPUs to train our models within a reasonable amount of time. GPUs contain hundreds of cores optimized for performing expensive matrix operations on floating-point numbers quickly, making them ideal for training deep neural networks. You can use GPUs for free on [Google Colab](https://colab.research.google.com/) and [Kaggle](https://www.kaggle.com/kernels) or rent GPU-powered machines on services like [Google Cloud Platform](https://cloud.google.com/gpu/), [Amazon Web Services](https://docs.aws.amazon.com/dlami/latest/devguide/gpu.html), and [Paperspace](https://www.paperspace.com/).\n# \n# We can check if a GPU is available and the required NVIDIA CUDA drivers are installed using `torch.cuda.is_available`.\n\n# In[281]:\n\n\ntorch.cuda.is_available()\n\n\n# Let's define a helper function to ensure that our code uses the GPU if available and defaults to using the CPU if it isn't. \n\n# In[282]:\n\n\ndef get_default_device():\n    \"\"\"Pick GPU if available, else CPU\"\"\"\n    if torch.cuda.is_available():\n        return torch.device('cuda')\n    else:\n        return torch.device('cpu')\n\n\n# In[283]:\n\n\ndevice = get_default_device()\n\n\n\n# Next, let's define a function that can move data and model to a chosen device.\n\n# In[284]:\n\n\ndef to_device(data, device):\n    \"\"\"Move tensor(s) to chosen device\"\"\"\n    if isinstance(data, (list,tuple)):\n        return [to_device(x, device) for x in data]\n    return data.to(device, non_blocking=True)\n\n\n# In[285]:\n\n\nfor images, labels in train_loader:\n    print(images.shape)\n    images = to_device(images, device)\n    print(images.device)\n    break\n\n\n# Finally, we define a `DeviceDataLoader` class to wrap our existing data loaders and move batches of data to the selected device. Interestingly, we don't need to extend an existing class to create a PyTorch datal oader. All we need is an `__iter__` method to retrieve batches of data and an `__len__` method to get the number of batches.\n\n# In[286]:\n\n\nclass DeviceDataLoader():\n    \"\"\"Wrap a dataloader to move data to a device\"\"\"\n    def __init__(self, dl, device):\n        self.dl = dl\n        self.device = device\n        \n    def __iter__(self):\n        \"\"\"Yield a batch of data after moving it to device\"\"\"\n        for b in self.dl: \n            yield to_device(b, self.device)\n\n    def __len__(self):\n        \"\"\"Number of batches\"\"\"\n        return len(self.dl)\n\n\n# The `yield` keyword in Python is used to create a generator function that can be used within a `for` loop, as illustrated below.\n\n# In[287]:\n\n\ndef some_numbers():\n    yield 10\n    yield 20\n    yield 30\n\nfor value in some_numbers():\n    print(value)\n\n\n# We can now wrap our data loaders using `DeviceDataLoader`.\n\n# In[288]:\n\n\ntrain_loader = DeviceDataLoader(train_loader, device)\nval_loader = DeviceDataLoader(val_loader, device)\n\n\n# Tensors moved to the GPU have a `device` property which includes that word `cuda`. Let's verify this by looking at a batch of data from `valid_dl`.\n\n# In[289]:\n\n\nfor xb, yb in val_loader:\n    print('xb.device:', xb.device)\n    print('yb:', yb)\n    break\n\n\n# ## Training the Model\n# \n# We'll define two functions: `fit` and `evaluate` to train the model using gradient descent and evaluate its performance on the validation set. For a detailed walkthrough of these functions, check out the [previous tutorial](https://jovian.ai/aakashns/03-logistic-regression).\n\n# In[290]:\n\n\ndef evaluate(model, val_loader):\n    \"\"\"Evaluate the model's performance on the validation set\"\"\"\n    outputs = [model.validation_step(batch) for batch in val_loader]\n    return model.validation_epoch_end(outputs)\n\ndef fit(epochs, lr, model, train_loader, val_loader, opt_func=torch.optim.SGD):\n    \"\"\"Train the model using gradient descent\"\"\"\n    history = []\n    optimizer = opt_func(model.parameters(), lr)\n    for epoch in range(epochs):\n        # Training Phase \n        for batch in train_loader:\n            loss = model.training_step(batch)\n            loss.backward()\n            optimizer.step()\n            optimizer.zero_grad()\n        # Validation phase\n        result = evaluate(model, val_loader)\n        model.epoch_end(epoch, result)\n        history.append(result)\n    return history\n\n\n# Before we train the model, we need to ensure that the data and the model's parameters (weights and biases) are on the same device (CPU or GPU). We can reuse the `to_device` function to move the model's parameters to the right device. \n\n# In[291]:\n\n\n# Model (on GPU)\nmodel = MnistModel(input_size, hidden_size=hidden_size, out_size=num_classes)\nto_device(model, device)\n\n\n# Let's see how the model performs on the validation set with the initial set of weights and biases.\n\n# In[292]:\n\n\nhistory = [evaluate(model, val_loader)]\n\n# The initial accuracy is around 10%, as one might expect from a randomly initialized model (since it has a 1 in 10 chance of getting a label right by guessing randomly).\n# \n# Let's train the model for five epochs and look at the results. We can use a relatively high learning rate of 0.5.\n\n# In[293]:\n\n\nhistory += fit(5, 0.5, model, train_loader, val_loader)\n\n\n# 96% is pretty good! Let's train the model for five more epochs at a lower learning rate of 0.1 to improve the accuracy further.\n\n# In[179]:\n\n\nhistory += fit(10, 0.001, model, train_loader, val_loader)\n\n\n# We can now plot the losses & accuracies to study how the model improves over time.\n\n# In[180]:\n\n\nlosses = [x['val_loss'] for x in history]\nplt.plot(losses, '-x')\nplt.xlabel('epoch')\nplt.ylabel('loss')\nplt.title('Loss vs. No. of epochs');\n\n\n# In[181]:\n\n\naccuracies = [x['val_acc'] for x in history]\nplt.plot(accuracies, '-x')\nplt.xlabel('epoch')\nplt.ylabel('accuracy')\nplt.title('Accuracy vs. No. of epochs');\n\n\n# Our current model outperforms the logistic regression model (which could only achieve around 86% accuracy) by a considerable margin! It quickly reaches an accuracy of 97% but doesn't improve much beyond this. To improve accuracy further, we need to make the model more powerful by increasing the hidden layer's size or adding more hidden layers with activations. I encourage you to try out both these approaches and see which one works better.\n\n# As a final step, we can save and commit our work using the `jovian` library.\n\n\n# ## Testing with individual images\n# \n# While we have been tracking the overall accuracy of a model so far, it's also a good idea to look at model's results on some sample images. Let's test out our model with some images from the predefined test dataset of 10000 images. We begin by recreating the test dataset with the `ToTensor` transform.\n\n# In[69]:\n\n\n# Define test dataset\ntest_dataset = MNIST(root='data/', \n                     train=False,\n                     transform=ToTensor())\n\n\n# Let's define a helper function `predict_image`, which returns the predicted label for a single image tensor.\n\n# In[70]:\n\n\ndef predict_image(img, model):\n    xb = to_device(img.unsqueeze(0), device)\n    yb = model(xb)\n    _, preds  = torch.max(yb, dim=1)\n    return preds[0].item()\n\n\n# Let's try it out with a few images.\n\n# In[71]:\n\n\nimg, label = test_dataset[0]\nplt.imshow(img[0], cmap='gray')\nprint('Label:', label, ', Predicted:', predict_image(img, model))\n\n\n# In[72]:\n\n\nimg, label = test_dataset[1839]\nplt.imshow(img[0], cmap='gray')\nprint('Label:', label, ', Predicted:', predict_image(img, model))\n\n\n# In[73]:\n\n\nimg, label = test_dataset[193]\nplt.imshow(img[0], cmap='gray')\nprint('Label:', label, ', Predicted:', predict_image(img, model))\n\n\n# Identifying where our model performs poorly can help us improve the model, by collecting more training data, increasing/decreasing the complexity of the model, and changing the hypeparameters.\n# \n# As a final step, let's also look at the overall loss and accuracy of the model on the test set.\n\n# In[74]:\n\n\ntest_loader = DeviceDataLoader(DataLoader(test_dataset, batch_size=256), device)\nresult = evaluate(model, test_loader)\nresult\n\n\n# We expect this to be similar to the accuracy/loss on the validation set. If not, we might need a better validation set that has similar data and distribution as the test set (which often comes from real world data).\n\n# Let's save the model's weights and attach it to the notebook using `jovian.commit`. We will also record the model's performance on the test dataset using `jovian.log_metrics`.\n\n# In[75]:\n\n\n# In[76]:\n\n\ntorch.save(model.state_dict(), 'mnist-feedforward.pth')\n\n\n# In[ ]:\n\n\n\n# ## Exercises\n# \n# Try out the following exercises to apply the concepts and techniques you have learned so far:\n# \n# * Coding exercises on end-to-end model training: https://jovian.ai/aakashns/03-cifar10-feedforward\n# * Starter notebook for deep learning models:  https://jovian.ai/aakashns/fashion-feedforward-minimal\n# \n# Training great machine learning models reliably takes practice and experience. Try experimenting with different datasets, models and hyperparameters, it's the best way to acquire this skill.\n\n# ## Summary and Further Reading\n# \n# Here is a summary of the topics covered in this tutorial:\n# \n# * We created a neural network with one hidden layer to improve upon the logistic regression model from the previous tutorial. We also used the ReLU activation function to introduce non-linearity into the model, allowing it to learn more complex relationships between the inputs (pixel densities) and outputs (class probabilities).\n# \n# * We defined some utilities like `get_default_device`, `to_device` and `DeviceDataLoader` to leverage a GPU if available, by moving the input data and model parameters to the appropriate device.\n# \n# * We were able to use the exact same training loop: the `fit` function we had define earlier to train out model and evaluate it using the validation dataset.\n# \n# There's a lot of scope to experiment here, and I encourage you to use the interactive nature of Jupyter to play around with the various parameters. Here are a few ideas:\n# \n# * Try changing the size of the hidden layer, or add more hidden layers and see if you can achieve a higher accuracy.\n# \n# * Try changing the batch size and learning rate to see if you can achieve the same accuracy in fewer epochs.\n# \n# * Compare the training times on a CPU vs. GPU. Do you see a significant difference. How does it vary with the size of the dataset and the size of the model (no. of weights and parameters)?\n# \n# * Try building a model for a different dataset, such as the [CIFAR10 or CIFAR100 datasets](https://www.cs.toronto.edu/~kriz/cifar.html).\n# \n# Here are some references for further reading:\n# \n# * [A visual proof that neural networks can compute any function](http://neuralnetworksanddeeplearning.com/chap4.html), also known as the Universal Approximation Theorem.\n# \n# * [But what *is* a neural network?](https://www.youtube.com/watch?v=aircAruvnKk) - A visual and intuitive introduction to what neural networks are and what the intermediate layers represent\n# \n# * [Stanford CS229 Lecture notes on Backpropagation](http://cs229.stanford.edu/notes/cs229-notes-backprop.pdf) - for a more mathematical treatment of how gradients are calculated and weights are updated for neural networks with multiple layers.\n# \n# \n# You are now ready to move on to the next tutorial: [Image Classification using Convolutional Neural Networks](https://jovian.ai/aakashns/05-cifar10-cnn).\n", "meta": {"hexsha": "ac47096a1d835565e78a0ea7b45c16b58b308f66", "size": 32566, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/04-feedforward-nn.py", "max_stars_repo_name": "BitShifter88/DeepLearning", "max_stars_repo_head_hexsha": "921048b2529911b44dfec98da640fb623f2dfd80", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/04-feedforward-nn.py", "max_issues_repo_name": "BitShifter88/DeepLearning", "max_issues_repo_head_hexsha": "921048b2529911b44dfec98da640fb623f2dfd80", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/04-feedforward-nn.py", "max_forks_repo_name": "BitShifter88/DeepLearning", "max_forks_repo_head_hexsha": "921048b2529911b44dfec98da640fb623f2dfd80", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.8604651163, "max_line_length": 656, "alphanum_fraction": 0.7313455751, "include": true, "reason": "import numpy", "num_tokens": 7746, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44552953503957266, "lm_q2_score": 0.15203224738527768, "lm_q1q2_score": 0.06773485648858404}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Team13: Capstone project of Python Bootcamp\n# \n# This is [the Capstone project for Team 13 of the Python Data Analysis Bootcamp](https://github.com/pyladiesams/Bootcamp-Data-Analysis-beginner-apr-may2020/blob/master/Capstone/README.md).\n# We are trying, more or less, to follow the structure of [jupytemplate](https://github.com/xtreamsrl/jupytemplate/blob/master/jupytemplate/jupytemplate/template.ipynb).\n# \n# ## Purpose\n# \n# State the purpose of the notebook.\n# \n# ## Methology\n# \n# Quickly describe assumptions and processing steps.\n# \n# ## TODO / Improvements\n# \n# * [x] Find a dataset that has at least 2 CSV files\n# * [ ] Come up with 5 questions that you want to answer while exploring the dataset\n# * [ ] Perform EDA (Exploratoty Data Analysis) on your dataset with basic visualisations\n# \n# ## Results\n\n# ## Setup\n\n# In[1]:\n\n\n# install system dependencies\nimport sys\nimport os\n\nget_ipython().system('conda install -c conda-forge --yes --prefix {sys.prefix} pandas jupyterthemes seaborn jupyter_contrib_nbextensions pandoc')\n\n\n# ### Library Import\n\n# In[2]:\n\n\n# load libraries and setup environment\n# mandatory\nimport pandas as pd\n\nget_ipython().run_line_magic('matplotlib', 'inline')\nimport matplotlib.pyplot as plt\n\n# optional\nimport numpy as np\nimport seaborn as sns\nfrom jupyterthemes import jtplot\nfrom IPython.core.display import HTML\njtplot.style(theme='monokai', context='notebook', ticks=True, grid=False)\n\n\n# ## Parameter definition\n# \n# We set all relevant parameters for our notebook. By convention, parameters are uppercase, while all the other variables follow Python's guidelines.\n\n# In[3]:\n\n\nCOAST_COLUMN = \"Coastline (coast/area ratio)\"\nCOUNTRY_COLUMN = 'Country'\nSATISFACTION_COLUMN = \"People with highest life satisfaction [%]\"\n\n\n# ## Data import\n# We retrieve all the required data for the analysis.\n\n# In[4]:\n\n\ncost_of_living = pd.read_csv('../data/andytran11996_cost-of-living/datasets_73059_162758_cost-of-living-2018.csv')\n\n# we are droppping the Rank column because it's entirely empty\ncost_of_living = cost_of_living.drop(columns = 'Rank')\n\nlife_satisfaction = pd.read_csv('../data/roshansharma_europe-datasets/datasets_231225_493692_life_satisfaction_2013.csv')\nlife_satisfaction = life_satisfaction.rename(columns = { \"prct_life_satis_high\": \"People with highest life satisfaction [%]\", \"country\": \"Country\" })\nlife_satisfaction['Country'] = life_satisfaction['Country'].astype(str)\nlife_satisfaction['Country'] = life_satisfaction['Country'].str.strip()\n\ngeneric_country_data = pd.read_csv('../data/fernandol_countries-of-the-world/datasets_23752_30346_countries of the world.csv', decimal=',')\ngeneric_country_data['Country'] = generic_country_data['Country'].astype(str)\ngeneric_country_data['Country'] = generic_country_data['Country'].str.strip()\ngeneric_european_country_data = generic_country_data[generic_country_data['Region'].str.contains('EUROPE', case = False)]\n\nprint('successfully imported the datasets.')\n\n\n# ## Data processing\n# \n# ### 1. What are the five cities with the highest/lowest cost of living (incl. rent)?\n\n# In[5]:\n\n\ncaption_column = 'City'\nindex_column = 'Cost of Living Plus Rent Index'\n\ndef display_cost_of_living(costs, title):\n    filtered_costs = costs[[caption_column, index_column]].sort_values(index_column, ascending = True)\n    filtered_costs.plot.barh(title = title, x = caption_column, y = index_column)\n    plt.show();\n    display(filtered_costs.sort_values(index_column, ascending = False).style.hide_index())\n\n# print the ten most expensive cities in the database in 2018\ndisplay_cost_of_living(cost_of_living.nlargest(5, index_column), 'Largest Rent Index')\ndisplay_cost_of_living(cost_of_living.nsmallest(5, index_column), 'Smallest Rent Index')\n\n\n# ## 2. What are the five happiest countries in Europe?\n\n# In[6]:\n\n\nindex_column = \"People with highest life satisfaction [%]\"\ncaption_column = 'Country'\n\ntop_countries_life_satisfaction = life_satisfaction[[caption_column, index_column]]\ntop_countries_life_satisfaction = top_countries_life_satisfaction.nlargest(5, index_column)\ntop_countries_life_satisfaction = top_countries_life_satisfaction.sort_values(index_column, ascending = True)\ntop_countries_life_satisfaction.plot.barh(title = 'Percentage of satisfied people', x = caption_column, y = index_column);\nplt.show();\ndisplay(top_countries_life_satisfaction.sort_values(index_column, ascending = False).style.hide_index())\n\n\n# ## 3. What are the European countries with the most coast line in relation to their area?\n\n# In[7]:\n\n\nindex_column = \"Coastline (coast/area ratio)\"\ncaption_column = 'Country'\n\ncoastline_data = generic_european_country_data[[caption_column, index_column]]\n\ncoastline_data = coastline_data.nlargest(5, index_column)\ncoastline_data = coastline_data.sort_values(index_column, ascending = True)\ncoastline_data.plot.barh(title = 'Countries with the most coast line in relation to their area', x = caption_column, y = index_column);\nplt.show();\ndisplay(coastline_data.sort_values(index_column, ascending = False).style.hide_index())\n\n\n# ## 4. Is there a correlation between happiness and access to a coastline?\n\n# In[9]:\n\n\nmerged = pd.merge(generic_european_country_data, life_satisfaction, on = COUNTRY_COLUMN, how = 'inner')  \n\ncoastline_data = generic_european_country_data[[COAST_COLUMN, COUNTRY_COLUMN]]\n\n# sort by coast\nmerged = merged.sort_values(COAST_COLUMN, ascending = True, ignore_index = True)\n\nax = plt.gca()\nmerged.plot(kind = 'line', y = COAST_COLUMN, x = COUNTRY_COLUMN ,ax=ax)\nmerged.plot(kind = 'line', y = SATISFACTION_COLUMN, x = COUNTRY_COLUMN ,ax=ax)\n\nplt.grid(b = True, color = 'aqua', alpha = 0.1, linestyle = 'dashdot')\nplt.show();\n\n\n# ## References\n# \n# * [data for the cost of living](https://www.kaggle.com/andytran11996/cost-of-living/)\n# * [base data for countries of the world](https://www.kaggle.com/fernandol/countries-of-the-world)\n# * [data for life expectancy from the WHO](https://www.kaggle.com/kumarajarshi/life-expectancy-who)\n# * [roshansharma_europe-datasets](https://www.kaggle.com/roshansharma/europe-datasets)\n", "meta": {"hexsha": "5ec0364db6b43e2ae3cbc612286b20220229c8b4", "size": 6108, "ext": "py", "lang": "Python", "max_stars_repo_path": "deliver/team13_capstone_project.py", "max_stars_repo_name": "s-gerber/python_bootcamp_team13", "max_stars_repo_head_hexsha": "127a9d4a2190d2dcd170f1a1a168591c9d9bc28c", "max_stars_repo_licenses": ["RSA-MD"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "deliver/team13_capstone_project.py", "max_issues_repo_name": "s-gerber/python_bootcamp_team13", "max_issues_repo_head_hexsha": "127a9d4a2190d2dcd170f1a1a168591c9d9bc28c", "max_issues_repo_licenses": ["RSA-MD"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "deliver/team13_capstone_project.py", "max_forks_repo_name": "s-gerber/python_bootcamp_team13", "max_forks_repo_head_hexsha": "127a9d4a2190d2dcd170f1a1a168591c9d9bc28c", "max_forks_repo_licenses": ["RSA-MD"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.3063583815, "max_line_length": 189, "alphanum_fraction": 0.7680091683, "include": true, "reason": "import numpy", "num_tokens": 1515, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44167300566462564, "lm_q2_score": 0.1500288262426238, "lm_q1q2_score": 0.06626368262291552}}
{"text": "![Callysto.ca Banner](https://github.com/callysto/curriculum-notebooks/blob/master/callysto-notebook-banner-top.jpg?raw=true)\n \n<a href=\"https://hub.callysto.ca/jupyter/hub/user-redirect/git-pull?repo=https%3A%2F%2Fgithub.com%2Fcallysto%2Fonline-courses&branch=master&subPath=Mathematics/ProbabilityExperiment/probability-experiment.ipynb&depth=1\" target=\"_parent\"><img src=\"https://raw.githubusercontent.com/callysto/curriculum-notebooks/master/open-in-callysto-button.svg?sanitize=true\" width=\"123\" height=\"24\" alt=\"Open in Callysto\"></a>\n\nTo run this notebook press the >> Button and confirm \"Restart and Run all\".\n\n![](./images/RunB.png)\n\nfrom IPython.display import HTML\n\nHTML('''<script>\ncode_show=true; \nfunction code_toggle() {\n if (code_show){\n $('div.input').hide();\n } else {\n $('div.input').show();\n }\n code_show = !code_show\n} \n$( document ).ready(code_toggle);\n</script>\nThe raw code for this IPython notebook is by default hidden for easier reading.\nTo toggle on/off the raw code, click <a href=\"javascript:code_toggle()\">here</a>.''')\n\n\n%%html\n<style>\n.output_wrapper button.btn.btn-default,\n.output_wrapper .ui-dialog-titlebar {\n  display: none;\n}\n</style>\n\n# Modules\n\nimport string\nimport numpy as np\nimport pandas as pd\nimport qgrid as q\nimport matplotlib.pyplot as plt\n\n# Widgets & Display modules, etc..\n\nfrom ipywidgets import widgets as w\nfrom ipywidgets import Button, Layout\nfrom IPython.display import display, Javascript, Markdown\n\n# grid features for interactive grids \n\ngrid_features = { 'fullWidthRows': True,\n                  'syncColumnCellResize': True,\n                  'forceFitColumns': True,\n                  'rowHeight': 40,\n                  'enableColumnReorder': True,\n                  'enableTextSelectionOnCells': True,\n                  'editable': True,\n                  'filterable': False,\n                  'sortable': False,\n                  'highlightSelectedRow': True}\n\nfrom ipywidgets import Button , Layout , interact,widgets\nfrom IPython.display import Javascript, display\n\n# Function: executes previous cell on button widget click event and hides achievement indicators message\n\ndef run_current(ev):\n    \n    display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+0,IPython.notebook.get_selected_index()+1)'))    \n    \n# Counter for toggling achievement indicator on/off\n\nbutton_ctr = 0\n\n# Achievement Indicators\n\nline_1 = \"#### Achievement Indicators\"\nline_2 = \"**General Outcome:**\"\nline_3 = \"* The general outcome of this notebook is to use experimental or theoretical probabilities to represent and solve problems involving uncertainty.\"\nline_4 = \"**Specific Outcome 4:**\"\nline_5 = \"* Express probabilities as ratios, fractions and percents.\"\nline_6 = \"**Specific Outcome 5:**\"\nline_7 = \"* Identify the sample space (where the combined sample space has 36 or fewer elements) for a probability experiment involving two independent events.*\"\nline_8 = \"**Specific Outcome 6:**\"\nline_9 = \"* Conduct a probability experiment to compare the theoretical probability (determined using a tree diagram, table or other graphic organizer) and experimental probability of two independent events*\"\n\n# Use to print lines, then save in lines_list\n\ndef print_lines(n):\n    \n    lines_str = \"\"\n    \n    for i in range(1,n+1):\n        lines_str = lines_str + \"line_\"+str(i)+\",\"\n        \n    lines_str = lines_str[:-1]\n\n    print(lines_str)\n    \nlines_list = [line_1,line_2,line_3,line_4,line_5,line_6,line_7,line_8,line_9]\n    \n# Show/Hide buttons\n\nai_button_show = widgets.Button(button_style='info',description=\"Show Achievement Indicators\", layout=Layout(width='25%', height='30px') )\nai_button_hide = widgets.Button(button_style='info',description=\"Hide Achievement Indicators\", layout=Layout(width='25%', height='30px') )\n\ndisplay(Markdown(\"For instructors:\"))\n\nbutton_ctr += 1\n\nif(button_ctr % 2 == 0):\n\n    for line in lines_list:\n        display(Markdown(line))\n    \n    display(ai_button_hide)\n    ai_button_hide.on_click( run_current )\n    \nelse:\n\n    display(ai_button_show)\n    ai_button_show.on_click( run_current )\n\n# Statistics and Probability \n\n## Chance and Uncertainty\n\n#### Grade 11  Math \n\n<h2 align='center'>Overview</h2>\n\nIn this notebook we will explore basic notions and properties about expressing and manipulating probabilities. \nThe general outcome of this notebook is to use experimental or theoretical probabilities to represent and solve problems involving uncertainty.\n\n<h2 align='center'>Probabilities as ratios, fractions and percents</h2>\n\nA natural question to ask is: how do we measure the probability associated to an event of a given probability experiment, i.e. for a given event, what is the probability it occurs?  We define this now, illustrate with a simple example involving dice, and we will then provide an interactive exercise. \n\n\n<div class=\"alert alert-warning\">\n<font color=\"black\"><b>Definition.</b> The probability of an event is the ratio between the size of the event (as a collection of outcomes) and the size of the sample space. </font>\n</div>\n\nThe sample space of rolling a single dice is given by $\\lbrace$1,2,3,4,5,6 $\\rbrace$ and had sample size 6.  If we assume each face is equally likely to occur (i.e. the dice is unbiased), then the probability of getting each face is the ratio or fraction $\\dfrac{1}{6}$. \n\nWe will denote the probability of getting each number as $P(i)$, where $i$ can either be 1,2,3,4,5,6. \nThen, the probability of getting event 1, denoted $P(1)$ is equal to $\\dfrac{1}{6}$; more precisely: $P(1)=P(2)=P(3)=P(4)=P(5)=P(6)=\\dfrac{1}{6}$.\n\nThis is equivalent to stating that the probability of getting any given face is 1 in 6, or $1:6$. Using ratios we have $P(i) = 1:6$, where $i = 1,2,3,4,5,6$. We can also express probabilities using percents. The total number of outcomes is considered 100%. Since there are 6 possible outcomes and assuming equal probability, $P(i) = 100 / 6  = 16.67 \\%$. \n\nWe summarize in the table below.\n\n|Event  $i$                  |1 |2 |3 |4 |5 |6 |\n|----------------------------|--|--|--|--|--|--|\n|Probability $P(i)$ as a fraction|$\\dfrac{1}{6}$|$\\dfrac{1}{6}$|$\\dfrac{1}{6}$|$\\dfrac{1}{6}$|$\\dfrac{1}{6}$|$\\dfrac{1}{6}$|\n|Probability $P(i)$ as a ratio            |1:6|1:6|1:6|1:6|1:6|1:6|\n|Probability $P(i)$ as a percent|16.67%|16.67%|16.67%|16.67%|16.67%|16.67%|\n\nimport numpy as np\nimport matplotlib \nfrom matplotlib.patches import Rectangle\nimport matplotlib.pyplot as plt\nimport matplotlib.cm as cm\nimport random\nimport matplotlib.gridspec as gridspec\nimport ipywidgets\nfrom ipywidgets import interact,interact_manual,widgets\n%matplotlib inline\n\n### Interactive Example: Probabilities as Fractions, Ratios and Percents\n\nThe widget below illustrates a probability experiment using roulettes of various sizes. The basic experiment consists in spinning  a roulette, divided in a given number of compartments, each of the same size and associated with a unique number that identifies it. The outcome of the experiment is the compartment of the roulette whose number shows in red. Basically, this is an experiment similar to rolling a dice, but where we control the number of faces (number of compartments in the roulette). We assume the roulette is unbiased: each compartment has the same chance to appear in red whenspinning the roulette.\n\nOn the upper side of the widget you find a drop down menu indicating the size of the sample space, which is the number of compartments of the roulette. In this case, we are considering roulettes whose outcomes are integers from 1 to the size of the sample space. We consider roulettes with sample spaces of size 2, 4, 6 and 8.\n\nBelow the drop down menu you will find find a red button. Click it to play. \n\nOn the left hand side of the widget you will see a roulette with numbers in black and one number in red. The number in red corresponds to the outcome of the experiment. \n\nOn the right hand side you will find a printed message explaining what the probability of the event associated to the obtained outcome is. \n\nPlay multiple times to simulate what would happen if you spun the roulette. Change the size of the sample space to learn what the different probabilities associated to each event in the roulette are. \n\n### \ndef roulette(number_parititions,value):\n    if value==True or value==False:\n        lucky_number_one = random.choice(np.arange(1,2*number_parititions+1))\n\n        \n        axalpha = 0.05\n        figcolor = 'white'\n        dpi = 80\n        fig = plt.figure(figsize=(15,10), dpi=dpi,facecolor='black')\n        plt.subplot(211)\n\n        plt.subplot(212)\n\n        fig.patch.set_edgecolor(figcolor)\n        fig.patch.set_facecolor(figcolor)\n        ax = plt.subplot(121,projection='polar',facecolor=\"red\")\n        \n\n        ax.patch.set_alpha(axalpha)\n        ax.set_axisbelow(True)\n        \n        ax1 = plt.subplot(122)\n        ax1.grid(False)\n        ax1.set_xlim(0.1,0.9)\n        ax1.set_ylim(0.4,0.8)\n        \n        ax1.set_xticklabels([])\n        ax1.set_yticklabels([])\n        ax1.axis(\"off\")\n    \n        arc = 2. * np.pi\n        N = number_parititions\n        theta = np.arange(0.0, arc, arc/N)\n        \n        if number_parititions == 4:\n            radii_ar = [1.0 for i in range(number_parititions)]\n            width_ar = [1.0 for i in range(number_parititions)]\n    \n            radii = 10 * np.array(radii_ar)\n            width = np.pi/4  * np.array(width_ar)\n    \n            bars = ax.bar(theta, radii, width=width, bottom=0.0)\n            for r, bar in zip(radii, bars):\n                bar.set_facecolor(\"pink\")\n                bar.set_alpha(0.6)\n            \n            ax.text(0, 7, \"1\", fontsize=20,transform=ax.transData._b,)\n            ax.text(5, 5, \"2\", fontsize=20,transform=ax.transData._b)\n            ax.text(7, 0, \"3\", fontsize=20,transform=ax.transData._b)\n            ax.text(4, -5.5, \"4\", fontsize=20,transform=ax.transData._b)\n            ax.text(0, -7, \"5\", fontsize=20,transform=ax.transData._b)\n            ax.text(-5, -5, \"6\", fontsize=20,transform=ax.transData._b)\n            ax.text(-5, 5, \"8\", fontsize=20,transform=ax.transData._b)\n            ax.text(-7, 0, \"7\", fontsize=20,transform=ax.transData._b)\n            \n            if lucky_number_one==1:\n                ax.text(0, 7, \"1\", fontsize=20,transform=ax.transData._b,color=\"red\")\n            elif lucky_number_one==2:\n                ax.text(5, 5, \"2\", fontsize=20,transform=ax.transData._b,color=\"red\")\n            elif lucky_number_one==3:\n                ax.text(7, 0, \"3\", fontsize=20,transform=ax.transData._b,color='red')\n            elif lucky_number_one==4:\n                ax.text(4, -5.5, \"4\", fontsize=20,transform=ax.transData._b,color='red')\n            elif lucky_number_one==5:\n                ax.text(0, -7, \"5\", fontsize=20,transform=ax.transData._b,color=\"red\")\n            elif lucky_number_one==6:\n                ax.text(-5, -5, \"6\", fontsize=20,transform=ax.transData._b,color=\"red\")\n            elif lucky_number_one==7:\n                ax.text(-7, 0, \"7\", fontsize=20,transform=ax.transData._b,color='red')\n            elif lucky_number_one==8:\n                ax.text(-5, 5, \"8\", fontsize=20,transform=ax.transData._b,color='red')\n            ax1.text(0.1,0.77,\"Probability of each event\",fontsize=25)\n            ax1.text(0.1,0.5,\"P(1) = 1/8 = 1:8 = 12.5%\\n\\nP(2) = 1/8 = 1:8 = 12.5%\\n\\nP(3) = 1/8 = 1:8 = 12.5%\\n\\nP(4) = 1/8 = 1:8 = 12.5%\\n\\nP(5) = 1/8 = 1:8 = 12.5%\\n\\nP(6) = 1/8 = 1:8 = 12.5%\\n\\nP(7) = 1/8 = 1:8 = 12.5%\\n\\nP(8) = 1/8 = 1:8 = 12.5%\"\\\n                      ,fontsize=20)\n            ax1.text(0.1,0.45,\"Probability Outcome\",fontsize=25)\n            ax1.text(0.1,0.42,\"The result after spinning is \" + str(lucky_number_one),fontsize=20)\n\n        elif number_parititions == 3:\n    \n            radii_ar = [1.0 for i in range(number_parititions)]\n            width_ar = [1.3 for i in range(number_parititions)]\n    \n            radii = 10 * np.array(radii_ar)\n            width = np.pi/4  * np.array(width_ar)\n    \n            bars = ax.bar(theta, radii, width=width, bottom=0.0)\n            for r, bar in zip(radii, bars):\n                bar.set_facecolor(\"pink\")\n                bar.set_alpha(0.6)\n            ax.text(-4, 7, \"1\", fontsize=20,transform=ax.transData._b)\n            ax.text(3, 6.5, \"2\", fontsize=20,transform=ax.transData._b)\n            ax.text(7, 0, \"3\", fontsize=20,transform=ax.transData._b)\n            ax.text(3, -6.5, \"4\", fontsize=20,transform=ax.transData._b)\n            ax.text(-4, -7, \"5\", fontsize=20,transform=ax.transData._b)\n            ax.text(-8, 0, \"6\", fontsize=20,transform=ax.transData._b)\n            \n            if lucky_number_one==1:\n                ax.text(-4, 7, \"1\", fontsize=20,transform=ax.transData._b,color='red')\n            elif lucky_number_one==2:\n                ax.text(3, 6.5, \"2\", fontsize=20,transform=ax.transData._b,color='red')\n            elif lucky_number_one==3:\n                ax.text(7, 0, \"3\", fontsize=20,transform=ax.transData._b,color='red')\n            elif lucky_number_one==4:\n                ax.text(3, -6.5, \"4\", fontsize=20,transform=ax.transData._b,color='red')\n            elif lucky_number_one==5:\n                ax.text(-4, -7, \"5\", fontsize=20,transform=ax.transData._b,color='red')\n            elif lucky_number_one==6:\n                ax.text(-8, 0, \"6\", fontsize=20,transform=ax.transData._b,color='red')\n            \n            ax1.text(0.1,0.74,\"Probability of each event\",fontsize=25)\n            ax1.text(0.1,0.55,\"P(1) = 1/6 = 1:6 = 16.67%\\n\\nP(2) = 1/6 = 1:6 = 16.67%\\n\\nP(3) = 1/6 = 1:6 = 16.67\\n\\nP(4) = 1/6 = 1:6 = 16.67%\\n\\nP(5) = 1/6 = 1:6 = 16.67%\\n\\nP(6) = 1/6 = 1:6 = 16.67%\"\\\n                      ,fontsize=20)\n            ax1.text(0.1,0.5,\"Probability Outcome\",fontsize=25)\n            ax1.text(0.1,0.48,\"The result after spinning is \" + str(lucky_number_one),fontsize=20)\n\n            \n        elif number_parititions == 2:\n            radii_ar = [1.0 for i in range(number_parititions)]\n            width_ar = [1.7 for i in range(number_parititions)]\n    \n            radii = 10 * np.array(radii_ar)\n            width = np.pi/4  * np.array(width_ar)\n    \n            bars = ax.bar(theta, radii, width=width, bottom=0.0)\n            for r, bar in zip(radii, bars):\n                bar.set_facecolor(\"pink\")\n                bar.set_alpha(0.6)\n            ax.text(0, 8, \"1\", fontsize=20,transform=ax.transData._b)\n            ax.text(7, 0, \"2\", fontsize=20,transform=ax.transData._b)\n            ax.text(0, -8, \"3\", fontsize=20,transform=ax.transData._b)\n            ax.text(-8, 0, \"4\", fontsize=20,transform=ax.transData._b)\n            \n            if lucky_number_one==1:\n                ax.text(0, 8, \"1\", fontsize=20,transform=ax.transData._b,color='red')\n            elif lucky_number_one==2:\n                ax.text(7, 0, \"2\", fontsize=20,transform=ax.transData._b,color='red')\n            elif lucky_number_one==3:\n                ax.text(0, -8, \"3\", fontsize=20,transform=ax.transData._b,color='red')\n            elif lucky_number_one==4:\n                ax.text(-8, 0, \"4\", fontsize=20,transform=ax.transData._b,color='red')\n            \n            ax1.text(0.1,0.74,\"Probability of each event\",fontsize=25)\n            ax1.text(0.1,0.6,\"P(1) = 1/4 = 1:4 = 25%\\n\\nP(2) = 1/4 = 1:4 =25%\\n\\nP(3) = 1/4 = 1:4 =25%\\n\\nP(4) = 1/4 = 1:4 =25%\",fontsize=20)\n            #ax1.text(0.1,0.5,\"This is equivalent to 50%.\",fontsize=20)\n            ax1.text(0.1,0.54,\"Probability Outcome\",fontsize=25)\n            ax1.text(0.1,0.52,\"The result after spinning is \" + str(lucky_number_one),fontsize=20)\n\n\n        elif number_parititions == 1:\n            radii_ar = [1.0 for i in range(number_parititions)]\n            width_ar = [4 for i in range(number_parititions)]\n    \n            radii = 10 * np.array(radii_ar)\n            width = np.pi/4  * np.array(width_ar)\n    \n            bars = ax.bar(theta, radii, width=width, bottom=0.0)\n            for r, bar in zip(radii, bars):\n                bar.set_facecolor(\"pink\")\n                bar.set_alpha(0.6)\n            ax.text(8, 0, \"1\", fontsize=20,transform=ax.transData._b)\n            ax.text(-8, 0, \"2\", fontsize=20,transform=ax.transData._b)\n            \n            if lucky_number_one==1:\n                ax.text(8, 0, \"1\", fontsize=20,transform=ax.transData._b,color='red')\n            elif lucky_number_one==2:\n                ax.text(-8, 0, \"2\", fontsize=20,transform=ax.transData._b,color='red')\n            \n            ax1.text(0.1,0.7,\"Probability of each event\",fontsize=25)\n            ax1.text(0.1,0.6,\"P(1) = 1/2 = 1:2 = 50%\\n\\nP(2) = 1/2 = 1:2 =50%\",fontsize=20)\n            ax1.text(0.1,0.54,\"Probability Outcome\",fontsize=25)\n            ax1.text(0.1,0.52,\"The result after spinning is \" + str(lucky_number_one),fontsize=20)\n\n        ax.tick_params(labelbottom=False, labeltop=False,\n                   labelleft=False, labelright=False)\n\n        ax.grid(False)\n        ax.set_yticks(np.arange(1, 9, 2))\n        ax1.set_yticks([])\n        ax1.set_xticks([])\n    \n        ax1.set_title(\"Probabilities as fractions, ratios and percents\",fontsize=30)\n        plt.show()\n    \nstyle = {'description_width': 'initial'}    \nlucky = interact(roulette,number_parititions = widgets.Dropdown(\n    options={'Two': 1, 'Four': 2, 'Six': 3,'Eight':4},\n    value=4,\n    description='Size of sample space:',\n    style=style\n),\n    value = widgets.ToggleButton(\n        value=True,\n        description='Click to Play!',\n        disabled=False,\n        button_style='danger', # 'success', 'info', 'warning', 'danger' or ''\n        tooltip='Description',\n        icon='check'\n    ))\n\n\n### Question 1\n\nUsing fractions, what is the probability of the event 1, denoted $P(1)$, if the sample size of the roulette is 4?\n\nfrom ipywidgets import interact_manual,widgets\n\n\ns = {'description_width': 'initial'}        \n@interact(answer =widgets.Select(\n                    options=[\"Select option\",\"1/2\",\\\n                            \"4\",\"1/3\",\\\n                             \"1/4\"],\n                    value='Select option',\n                    description=\"Probability as fraction\",\n                    disabled=False,\n                    style=s\n))\n\ndef reflective_angle_question(answer):\n    if answer==\"Select option\":\n        print(\"Click on the correct probability expressed as a fraction.\")\n    \n    elif answer==\"1/4\":\n        print(\"Correct!\\nWith a sample space of size 4, each with equal likelihood, P(1)=1/4.\")\n    elif answer != \"1/4\" or answer != \"Select Option\":\n        print(\"Hint: What is P(1) if P(i) = 1/4 for all i = 1,2,3,4?\")\n\n### Question 2\n\nWhat is P(1) if the size of the sample space is 4, but this time expressed as percent?\n\nfrom ipywidgets import interact_manual,widgets\n\n\ns = {'description_width': 'initial'}        \n@interact(answer =widgets.Select(\n                    options=[\"Select option\",\"25%\",\\\n                            \"100%\",\"40%\",\\\n                             \"10%\"],\n                    value='Select option',\n                    description=\"Probability as percent\",\n                    disabled=False,\n                    style=s\n))\n\ndef reflective_angle_question(answer):\n    if answer==\"Select option\":\n        print(\"Click on the correct probability expressed in percent.\")\n    \n    elif answer==\"25%\":\n        print(\"Correct!\\nWith four probability events, each with equal likelihood, P(1) = 25%.\")\n    elif answer != \"25%\" or answer != \"Select Option\":\n        print(\"Hint: The total number of outcomes is 4, which corresponds to 100%. What is 100/4?\")\n\n### Question 3\n\nUsing the widget created above, change the Size of sample space to 8. What is $P(7)$ as a ratio? \n\nfrom ipywidgets import interact_manual,widgets\n\n\ns = {'description_width': 'initial'}        \n@interact(answer =widgets.Select(\n                    options=[\"Select option\",\"1:6\",\\\n                            \"1:4\",\"1:8\",\\\n                             \"1:7\"],\n                    value='Select option',\n                    description=\"Probability as ratio\",\n                    disabled=False,\n                    style=s\n))\n\ndef reflective_angle_question(answer):\n    if answer==\"Select option\":\n        print(\"Click on the correct probability expressed as a percentage.\")\n    \n    elif answer==\"1:8\":\n        print(\"Correct!\\nWith eight probability events, each with equal likelihood, \\nP(7) =  1:8.\")\n    elif answer != \"1:8\" or answer != \"Select Option\":\n        print(\"Hint: 1 in every 8 corresponds to the event 7. What is P(7) in ratio?\")\n\n<h2 align='center'>Independent Events & Sample Space</h2>\n<!-- Specific Outcome 5 Identify the sample space (where the combined sample space has 36 or fewer elements) for a probability experiment involving two independent events.-->\n\nIn this section, we define the concept of **independent probability experiments** as well as the corresponding sample space, and provide a game where we can experiment with the two concepts. \n\n<div class=\"alert alert-warning\">\n<font color=\"black\"><b>Definition.</b> We say that two probability experiments are <i>independent</i> if the outcome of one does not affect the outcome of the other. </font>\n</div>\n\nFor example, if we spin two roulettes at the same time, then the two experiments are independent since the outcome of each does not affect the other.\n\nTry spinning the two roulettes below via using the red button. As before, in each the number in red denotes the outcome of the experiment. These two roulettes are not linked and as you can see from a few spins, their outcomes are not related at all: spinning them are independent experiments.\n\ndef spin(value):\n    if value==True or value==False:\n        \n        lucky_number_one = random.choice([1,2,3,4,5,6])\n        \n        lucky_number_one_c = random.choice([1,2,3,4,5,6])\n        \n        x_t,y_t = [i/10 for i in range(10)],[i/10 for i in range(10)]\n\n        axalpha = 0.05\n        figcolor = 'white'\n        dpi = 80\n        \n        gs = gridspec.GridSpec(2, 3)\n        fig = plt.figure(figsize=(15,8), dpi=dpi,facecolor='black')      \n\n        fig.patch.set_edgecolor(figcolor)\n        fig.patch.set_facecolor(figcolor)\n        \n        ax1 = plt.subplot(gs[0, 0]) \n        ax1.grid(False)\n        ax1.axis(\"Off\")\n        ax2 = plt.subplot(gs[1, 0]) \n        ax2.grid(False)\n        ax2.axis(\"Off\")\n        ax5 = plt.subplot(gs[0, 2]) \n        ax5.grid(False)\n        ax5.axis(\"Off\")\n        ax6 = plt.subplot(gs[1, 2]) \n        ax6.grid(False)\n        ax6.axis(\"Off\")\n        #ax.axis(\"Off\")\n        \n        ax = plt.subplot(gs[0,0],projection='polar',facecolor=\"red\") # row 0, col 0\n        plt.plot([0,1])\n    \n        ax.plot(x_t,y_t,transform=ax.transData._b,color=\"#FEE9FF\",linewidth=5)\n            \n        ax.patch.set_alpha(axalpha)\n        ax.set_axisbelow(True)\n    \n        number_parititions = 3\n        arc = 2. * np.pi\n        N = number_parititions\n        theta = np.arange(0.0, arc, arc/N)\n    \n        radii_ar = [1.0 for i in range(number_parititions)]\n        width_ar = [1.3 for i in range(number_parititions)]\n    \n        radii = 10 * np.array(radii_ar)\n        width = np.pi/4  * np.array(width_ar)\n    \n        bars = ax.bar(theta, radii, width=width, bottom=0.0)\n        for r, bar in zip(radii, bars):\n            bar.set_facecolor(\"pink\")\n            bar.set_alpha(0.6)\n        ax.text(-4, 7, \"1\", fontsize=20,transform=ax.transData._b)\n        ax.text(3, 6.5, \"2\", fontsize=20,transform=ax.transData._b)\n        ax.text(7, 0, \"3\", fontsize=20,transform=ax.transData._b)\n        ax.text(3, -6.5, \"4\", fontsize=20,transform=ax.transData._b)\n        ax.text(-4, -7, \"5\", fontsize=20,transform=ax.transData._b)\n        ax.text(-8, 0, \"6\", fontsize=20,transform=ax.transData._b)\n        \n        if lucky_number_one==1:\n            #bar3.set_facecolor(\"#000000\")\n            ax.text(-4, 7, \"1\", fontsize=20,transform=ax.transData._b,color='red')\n        elif lucky_number_one==2:\n            #bar2.set_facecolor(\"#000000\")\n            ax.text(3, 6.5, \"2\", fontsize=20,transform=ax.transData._b,color='red')\n            \n        elif lucky_number_one==3:\n            #bar1.set_facecolor(\"#000000\")\n            ax.text(7, 0, \"3\", fontsize=20,transform=ax.transData._b,color='red')\n            \n        elif lucky_number_one==4:\n            #bar6.set_facecolor(\"#000000\")\n            ax.text(3, -6.5, \"4\", fontsize=20,transform=ax.transData._b,color='red')\n            \n        elif lucky_number_one==5:\n            #bar5.set_facecolor(\"#000000\")\n            ax.text(-4, -7, \"5\", fontsize=20,transform=ax.transData._b,color='red')\n            \n        elif lucky_number_one==6:\n            #bar4.set_facecolor(\"#000000\")\n            ax.text(-8, 0, \"6\", fontsize=20,transform=ax.transData._b,color='red')\n        \n        ax.tick_params(labelbottom=False, labeltop=False,\n                   labelleft=False, labelright=False)\n\n        ax.grid(False)\n        ax.axis(\"On\")\n        ax.set_title(\"Top Roulette\",fontsize=20)\n        \n        ax4 = plt.subplot(gs[1, 0],projection='polar',facecolor=\"red\") # row 0, col 0\n        plt.plot([0,1])\n\n        ax4.plot(x_t,y_t,transform=ax4.transData._b,color=\"#FEE9FF\",linewidth=5)\n        ax4.patch.set_alpha(axalpha)\n        ax4.set_axisbelow(True)\n    \n        bars = ax4.bar(theta, radii, width=width, bottom=0.0)\n        for r, bar in zip(radii, bars):\n            bar.set_facecolor(\"pink\")\n            bar.set_alpha(0.6)\n        ax4.text(-4, 7, \"1\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(3, 6.5, \"2\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(7, 0, \"3\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(3, -6.5, \"4\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(-4, -7, \"5\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(-8, 0, \"6\", fontsize=20,transform=ax4.transData._b)\n        \n        if lucky_number_one_c==1:\n            #bar3.set_facecolor(\"#000000\")\n            ax4.text(-4, 7, \"1\", fontsize=20,transform=ax4.transData._b,color='red')\n        elif lucky_number_one_c==2:\n            #bar2.set_facecolor(\"#000000\")\n            ax4.text(3, 6.5, \"2\", fontsize=20,transform=ax4.transData._b,color='red')\n            \n        elif lucky_number_one_c==3:\n            #bar1.set_facecolor(\"#000000\")\n            ax4.text(7, 0, \"3\", fontsize=20,transform=ax4.transData._b,color='red')\n            \n        elif lucky_number_one_c==4:\n            #bar6.set_facecolor(\"#000000\")\n            ax4.text(3, -6.5, \"4\", fontsize=20,transform=ax4.transData._b,color='red')\n            \n        elif lucky_number_one_c==5:\n            #bar5.set_facecolor(\"#000000\")\n            ax4.text(-4, -7, \"5\", fontsize=20,transform=ax4.transData._b,color='red')\n            \n        elif lucky_number_one_c==6:\n            #bar4.set_facecolor(\"#000000\")\n            ax4.text(-8, 0, \"6\", fontsize=20,transform=ax4.transData._b,color='red')\n        \n        ax4.tick_params(labelbottom=False, labeltop=False,\n                   labelleft=False, labelright=False)\n\n        ax4.grid(False)\n        ax4.axis(\"On\")\n        ax4.set_title(\"Bottom Roulette\",fontsize=20)\n        \n        x,y = np.array([i/10 for i in range(11)]),np.array([i/10 for i in range(11)])\n        \n        ax2 = plt.subplot(gs[0,1:]) # row 0, col 0\n        plt.plot([0,1])\n        \n        ax2.grid(False)\n        ax2.axis(\"Off\")\n        #ax2.set_title(\"Top Roulette Outcome\",fontsize=20)\n        ax2.plot(x,y,color='white',linewidth=4)\n        ax2.text(0.1,0.5,\"Top Roulette Outcome: \" +str(lucky_number_one),fontsize=20)\n        \n        ax5 = plt.subplot(gs[1,1:]) # row 0, col 0\n        plt.plot([0,1])\n        \n        ax5.grid(False)\n        ax5.axis(\"Off\")\n        #ax5.set_title(\"Bottom Roulette Outcome\",fontsize=20)\n        ax5.plot(x,y,color='white',linewidth=4)\n        ax5.text(0.1,0.5,\"Bottom Roulette Outcome: \" + str(lucky_number_one_c),fontsize=20)\n        \nlucky = interact(spin,value = widgets.ToggleButton(\n        value=True,\n        description=\"Spin\",\n        disabled=False,\n        button_style='danger', # 'success', 'info', 'warning', 'danger' or ''\n        tooltip='Description',\n        icon='check'\n    ))\n\nRecall that \n\n<div class=\"alert alert-warning\">\n    <font color=\"black\"><b>Definition.</b> The <i>sample space</i> of an experiment is the set of all possible outcomes of that experiment.</font>\n</div>\n\nIf, for example, we take the two roulettes above, we can define the sample space of spinning both of then at the same time as the set of all ordered pairs $(n_t,n_b)$, where $n_t$ denotes the outcome of spinning the top roulette and $n_b$ denotes the outcome of spinning the bottom roulette. This sample space is given by the table below, which is a 6 by 6 table where each entry is a pair $(n_t,n_b)$.\n\ndef spin_sample_space(value):\n    if value==True or value==False:\n        \n        lucky_number_one = random.choice([1,2,3,4,5,6])\n        \n        lucky_number_one_c = random.choice([1,2,3,4,5,6])\n        \n        x_t,y_t = [i/10 for i in range(10)],[i/10 for i in range(10)]\n    \n        axalpha = 0.05\n        figcolor = 'white'\n        dpi = 80\n        \n        gs = gridspec.GridSpec(2, 2)\n        fig = plt.figure(figsize=(15,8), dpi=dpi,facecolor='black')      \n\n        fig.patch.set_edgecolor(figcolor)\n        fig.patch.set_facecolor(figcolor)\n        ax = plt.subplot(gs[0, 0],projection='polar',facecolor=\"red\") \n        plt.plot([0,1])\n\n        ax.patch.set_alpha(axalpha)\n        ax.set_axisbelow(True)\n        \n        ax.plot(x_t,y_t,transform=ax.transData._b,color=\"#FEE9FF\",linewidth=5)\n    \n        number_parititions = 3\n        arc = 2. * np.pi\n        N = number_parititions\n        theta = np.arange(0.0, arc, arc/N)\n    \n        radii_ar = [1.0 for i in range(number_parititions)]\n        width_ar = [1.3 for i in range(number_parititions)]\n    \n        radii = 10 * np.array(radii_ar)\n        width = np.pi/4  * np.array(width_ar)\n    \n        bars = ax.bar(theta, radii, width=width, bottom=0.0)\n        for r, bar in zip(radii, bars):\n            bar.set_facecolor(\"pink\")\n            bar.set_alpha(0.6)\n        ax.text(-4, 7, \"1\", fontsize=20,transform=ax.transData._b)\n        ax.text(3, 6.5, \"2\", fontsize=20,transform=ax.transData._b)\n        ax.text(7, 0, \"3\", fontsize=20,transform=ax.transData._b)\n        ax.text(3, -6.5, \"4\", fontsize=20,transform=ax.transData._b)\n        ax.text(-4, -7, \"5\", fontsize=20,transform=ax.transData._b)\n        ax.text(-8, 0, \"6\", fontsize=20,transform=ax.transData._b)\n        \n        if lucky_number_one==1:\n            #bar3.set_facecolor(\"#000000\")\n            ax.text(-4, 7, \"1\", fontsize=20,transform=ax.transData._b,color='red')\n        elif lucky_number_one==2:\n            #bar2.set_facecolor(\"#000000\")\n            ax.text(3, 6.5, \"2\", fontsize=20,transform=ax.transData._b,color='red')\n            \n        elif lucky_number_one==3:\n            #bar1.set_facecolor(\"#000000\")\n            ax.text(7, 0, \"3\", fontsize=20,transform=ax.transData._b,color='red')\n            \n        elif lucky_number_one==4:\n            #bar6.set_facecolor(\"#000000\")\n            ax.text(3, -6.5, \"4\", fontsize=20,transform=ax.transData._b,color='red')\n            \n        elif lucky_number_one==5:\n            #bar5.set_facecolor(\"#000000\")\n            ax.text(-4, -7, \"5\", fontsize=20,transform=ax.transData._b,color='red')\n            \n        elif lucky_number_one==6:\n            #bar4.set_facecolor(\"#000000\")\n            ax.text(-8, 0, \"6\", fontsize=20,transform=ax.transData._b,color='red')\n        \n        ax.tick_params(labelbottom=False, labeltop=False,\n                   labelleft=False, labelright=False)\n\n        ax.grid(False)\n        ax.axis(\"On\")\n        ax.set_title(\"Top Roulette\",fontsize=20)\n        \n        ax4 = plt.subplot(gs[1, 0],projection='polar',facecolor=\"red\") # row 0, col 0\n        plt.plot([0,1])\n\n        ax4.patch.set_alpha(axalpha)\n        ax4.set_axisbelow(True)\n        \n        ax4.plot(x_t,y_t,transform=ax4.transData._b,color=\"#FEE9FF\",linewidth=5)\n        bars = ax4.bar(theta, radii, width=width, bottom=0.0)\n        for r, bar in zip(radii, bars):\n            bar.set_facecolor(\"pink\")\n            bar.set_alpha(0.6)\n        ax4.text(-4, 7, \"1\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(3, 6.5, \"2\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(7, 0, \"3\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(3, -6.5, \"4\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(-4, -7, \"5\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(-8, 0, \"6\", fontsize=20,transform=ax4.transData._b)\n        \n        if lucky_number_one_c==1:\n            #bar3.set_facecolor(\"#000000\")\n            ax4.text(-4, 7, \"1\", fontsize=20,transform=ax4.transData._b,color='red')\n        elif lucky_number_one_c==2:\n            #bar2.set_facecolor(\"#000000\")\n            ax4.text(3, 6.5, \"2\", fontsize=20,transform=ax4.transData._b,color='red')\n            \n        elif lucky_number_one_c==3:\n            #bar1.set_facecolor(\"#000000\")\n            ax4.text(7, 0, \"3\", fontsize=20,transform=ax4.transData._b,color='red')\n            \n        elif lucky_number_one_c==4:\n            #bar6.set_facecolor(\"#000000\")\n            ax4.text(3, -6.5, \"4\", fontsize=20,transform=ax4.transData._b,color='red')\n            \n        elif lucky_number_one_c==5:\n            #bar5.set_facecolor(\"#000000\")\n            ax4.text(-4, -7, \"5\", fontsize=20,transform=ax4.transData._b,color='red')\n            \n        elif lucky_number_one_c==6:\n            #bar4.set_facecolor(\"#000000\")\n            ax4.text(-8, 0, \"6\", fontsize=20,transform=ax4.transData._b,color='red')\n        \n        ax4.tick_params(labelbottom=False, labeltop=False,\n                   labelleft=False, labelright=False)\n\n        ax4.grid(False)\n        ax4.axis(\"On\")\n        ax4.set_title(\"Bottom Roulette\",fontsize=20)\n        \n        ax1 = plt.subplot(gs[:, 1:],facecolor='#0475A8') # row 1, span all columns\n        plt.plot([0,1])\n        ax1.set_axisbelow(True)\n        ax1.grid(color='black', linestyle='-', linewidth=2)\n        \n        ax1.set_xlim(0.1,0.7)\n        ax1.set_ylim(0.1,0.7)\n\n        rec = Rectangle([lucky_number_one/10,lucky_number_one_c/10],0.1,0.1,facecolor=\"black\")\n        ax1.add_patch(rec)\n        x,y = [lucky_number_one/10,lucky_number_one/10+ 0.1], [lucky_number_one_c/10,lucky_number_one_c/10 + 0.1]\n        ax1.plot(x,y,color='black',linewidth=4)\n        for i in range(1,7):\n            for j in range(1,7):\n                ax1.text(i/10 + 0.02,j/10 + 0.055,\"(\" + str(i)+\",\"+ str(j)+\")\",fontsize = 15,color='white') \n        ax1.set_xticklabels([\" \",1,2,3,4,5,6])\n        ax1.set_yticklabels([\" \",1,2,3,4,5,6])\n        ax1.set_xlabel(\"Top Roulette Outcome\",fontsize = 20)\n        ax1.set_ylabel(\"Bottom Roulette Outcome\",fontsize = 20)\n        ax1.xaxis.tick_top()\n        ax1.invert_yaxis()\n\n        plt.show()\n        \nlucky = interact(spin_sample_space,value = widgets.ToggleButton(\n        value=True,\n        description=\"Spin\",\n        disabled=False,\n        button_style='danger', # 'success', 'info', 'warning', 'danger' or ''\n        tooltip='Description',\n        icon='check'\n    ))\n\nIn this case, since the events are independent and each event has six possible outcomes, the sample space contains\n\n$$6 \\times 6 = 36$$\n\npossible outcomes, where each outcome is a pair of the form $(n_t,n_b)$. \n\nThe probability of obtaining any given pair $(n_t,n_b)$, is given by the probability of obtaining $n_t$ with the top roulette (first experiment) multiplied by the probability of obtaining $n_b$ with the bottom roulette (second experiment). If we assume that each event is equally likely to occur\n\n$$P(n_t,n_b) = \\dfrac{1}{6} \\times \\dfrac{1}{6} = \\dfrac{1}{36}$$\n\nNote that we can multiply \n* the sizes of the two sample spaces (for each roulette) to obtain the sample space size of the combined experiments\n* the probabilities of obtaining $n_t$ and $n_b$ to obtain the probability of the event $(n_t,n_b)$\n**because** the two experiments are **independent**. This is an important property of joint probability experiments.\n\n<div class=\"alert alert-warning\">\n<font color=\"black\"><b>Property.</b> Consider two independent probability experiments $E_1$ and $E_2$ of respective sample space sizes $N_1$ and $N_2$. The size of the sample space of the joint experiment $(E_1,E_2)$ is $N_1\\times N_2$. The probability of the event $(n_1,n_2)$ is $P(n_1)\\times P(n_2)$.</font>\n</div>\n\n## Question 4\n\nWhat is the probability assigned to the event (1,1)?\n\nfrom ipywidgets import interact_manual,widgets\n\ns = {'description_width': 'initial'}        \n@interact(answer =widgets.Select(\n                    options=[\"Select option\",\"2/36\",\\\n                            \"1/6\",\"36\",\\\n                             \"1/36\"],\n                    value='Select option',\n                    description=\"Probability as fraction\",\n                    disabled=False,\n                    style=s\n))\n\ndef reflective_angle_question(answer):\n    if answer==\"Select option\":\n        print(\"Click on the correct probability expressed as a fraction.\")\n    \n    elif answer==\"1/36\":\n        print(\"Correct!\")\n    elif answer != \"1/36\" or answer != \"Select Option\":\n        print(\"Hint: There are 36 events, each with equal likelihood of occurrence. \\nYou also know that each pair is unique.\")\n\n<h3 align='left'>A second example of a sample space</h3>\n\nLet's take the two roulettes as before but this time let's define the sample space of spinning both of them at the same time as the as the **parity** of the sum $$n_t + n_b$$ where as before $n_t$ denotes the outcome of the Top Roulette and $n_b$ denotes the outcome of the Bottom Roulette.\n\nThen the sample space is given by the set $\\lbrace \\text{even},\\text{odd} \\rbrace$\n\nThis sample space is given by the table below, which is a 6 by 6 table where each entry is a pair contains the **parity** of the sum $$n_t + n_b$$\n\ndef fair(value):\n    if value==True or value==False:\n        \n        lucky_number_one = random.choice([1,2,3,4,5,6])\n        lucky_number_one_c = random.choice([1,2,3,4,5,6])\n        \n        x_t,y_t = [i/10 for i in range(10)],[i/10 for i in range(10)]\n\n        axalpha = 0.05\n        figcolor = 'white'\n        dpi = 80\n        \n        gs = gridspec.GridSpec(2, 2)\n        fig = plt.figure(figsize=(15,8), dpi=dpi,facecolor='black')      \n\n        fig.patch.set_edgecolor(figcolor)\n        fig.patch.set_facecolor(figcolor)\n        ax = plt.subplot(gs[0, 0],projection='polar',facecolor=\"red\") # row 0, col 0\n        plt.plot([0,1])\n\n        ax.patch.set_alpha(axalpha)\n        ax.set_axisbelow(True)\n        ax.plot(x_t,y_t,transform=ax.transData._b,color=\"#FEE9FF\",linewidth=5)\n        number_parititions = 3\n        arc = 2. * np.pi\n        N = number_parititions\n        theta = np.arange(0.0, arc, arc/N)\n    \n        radii_ar = [1.0 for i in range(number_parititions)]\n        width_ar = [1.3 for i in range(number_parititions)]\n    \n        radii = 10 * np.array(radii_ar)\n        width = np.pi/4  * np.array(width_ar)\n    \n        bars = ax.bar(theta, radii, width=width, bottom=0.0)\n        for r, bar in zip(radii, bars):\n            bar.set_facecolor(\"pink\")\n            bar.set_alpha(0.6)\n        ax.text(-4, 7, \"1\", fontsize=20,transform=ax.transData._b)\n        ax.text(3, 6.5, \"2\", fontsize=20,transform=ax.transData._b)\n        ax.text(7, 0, \"3\", fontsize=20,transform=ax.transData._b)\n        ax.text(3, -6.5, \"4\", fontsize=20,transform=ax.transData._b)\n        ax.text(-4, -7, \"5\", fontsize=20,transform=ax.transData._b)\n        ax.text(-8, 0, \"6\", fontsize=20,transform=ax.transData._b)\n        \n        if lucky_number_one==1:\n            #bar3.set_facecolor(\"#000000\")\n            ax.text(-4, 7, \"1\", fontsize=20,transform=ax.transData._b,color='red')\n        elif lucky_number_one==2:\n            #bar2.set_facecolor(\"#000000\")\n            ax.text(3, 6.5, \"2\", fontsize=20,transform=ax.transData._b,color='red')\n            \n        elif lucky_number_one==3:\n            #bar1.set_facecolor(\"#000000\")\n            ax.text(7, 0, \"3\", fontsize=20,transform=ax.transData._b,color='red')\n            \n        elif lucky_number_one==4:\n            #bar6.set_facecolor(\"#000000\")\n            ax.text(3, -6.5, \"4\", fontsize=20,transform=ax.transData._b,color='red')\n            \n        elif lucky_number_one==5:\n            #bar5.set_facecolor(\"#000000\")\n            ax.text(-4, -7, \"5\", fontsize=20,transform=ax.transData._b,color='red')\n            \n        elif lucky_number_one==6:\n            #bar4.set_facecolor(\"#000000\")\n            ax.text(-8, 0, \"6\", fontsize=20,transform=ax.transData._b,color='red')\n        \n        ax.tick_params(labelbottom=False, labeltop=False,\n                   labelleft=False, labelright=False)\n\n        ax.grid(False)\n        ax.axis(\"On\")\n        ax.set_title(\"Top Roulette\",fontsize=20)\n        \n        ax1 = plt.subplot(gs[:, 1:],facecolor='#0475A8') # row 1, span all columns\n        plt.plot([0,1])\n        ax1.set_axisbelow(True)\n        ax1.grid(color='black', linestyle='-', linewidth=2)\n\n        ax1.set_xlim(0.1,0.7)\n        ax1.set_ylim(0.1,0.7)\n        ax1.set_xlabel(\"Top Roulette Outcome\",fontsize=18)\n        ax1.set_ylabel(\"Bottom Roulette Outcome\",fontsize=18)\n        ax1.xaxis.tick_top()\n        ax1.invert_yaxis()\n        #\n        for i in range(1,7):\n            for j in range(1,7):\n                if (i+j)%2==0:\n                    ax1.text(i/10 + 0.02,j/10 + 0.055,\"even\" ,fontsize = 15,color='white') \n                else:\n                    ax1.text(i/10 + 0.02,j/10 + 0.055,\"odd\" ,fontsize = 15,color='white') \n        \n        rec = Rectangle([lucky_number_one/10,lucky_number_one_c/10],0.1,0.1,facecolor=\"black\")\n        x,y = [lucky_number_one/10,lucky_number_one/10+ 0.1], [lucky_number_one_c/10,lucky_number_one_c/10 + 0.1]\n        ax1.plot(x,y,color='black',linewidth=4)\n        #rec_c = Rectangle([lucky_number_one_c/10,lucky_number_two_c/10],0.1,0.1,facecolor=\"#6b6e72\")\n        ax1.add_patch(rec)\n        #ax1.add_patch(rec_c)\n        ax1.set_xticklabels([\" \",1,2,3,4,5,6])\n        ax1.set_yticklabels([\" \",1,2,3,4,5,6])\n        \n        ax4 = plt.subplot(gs[1, 0],projection='polar',facecolor=\"red\") # row 0, col 0\n        plt.plot([0,1])\n\n        ax4.patch.set_alpha(axalpha)\n        ax4.set_axisbelow(True)\n        \n        ax4.plot(x_t,y_t,transform=ax4.transData._b,color=\"#FEE9FF\",linewidth=5)\n        \n        bars = ax4.bar(theta, radii, width=width, bottom=0.0)\n        for r, bar in zip(radii, bars):\n            bar.set_facecolor(\"pink\")\n            bar.set_alpha(0.6)\n        ax4.text(-4, 7, \"1\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(3, 6.5, \"2\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(7, 0, \"3\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(3, -6.5, \"4\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(-4, -7, \"5\", fontsize=20,transform=ax4.transData._b)\n        ax4.text(-8, 0, \"6\", fontsize=20,transform=ax4.transData._b)\n        \n        if lucky_number_one_c==1:\n            #bar3.set_facecolor(\"#000000\")\n            ax4.text(-4, 7, \"1\", fontsize=20,transform=ax4.transData._b,color='red')\n        elif lucky_number_one_c==2:\n            #bar2.set_facecolor(\"#000000\")\n            ax4.text(3, 6.5, \"2\", fontsize=20,transform=ax4.transData._b,color='red')\n            \n        elif lucky_number_one_c==3:\n            #bar1.set_facecolor(\"#000000\")\n            ax4.text(7, 0, \"3\", fontsize=20,transform=ax4.transData._b,color='red')\n            \n        elif lucky_number_one_c==4:\n            #bar6.set_facecolor(\"#000000\")\n            ax4.text(3, -6.5, \"4\", fontsize=20,transform=ax4.transData._b,color='red')\n            \n        elif lucky_number_one_c==5:\n            #bar5.set_facecolor(\"#000000\")\n            ax4.text(-4, -7, \"5\", fontsize=20,transform=ax4.transData._b,color='red')\n            \n        elif lucky_number_one_c==6:\n            #bar4.set_facecolor(\"#000000\")\n            ax4.text(-8, 0, \"6\", fontsize=20,transform=ax4.transData._b,color='red')\n        \n        ax4.tick_params(labelbottom=False, labeltop=False,\n                   labelleft=False, labelright=False)\n\n        ax4.grid(False)\n        ax4.axis(\"On\")\n        ax4.set_title(\"Bottom Roulette\",fontsize=20)\n\n        sum_n = lucky_number_one + lucky_number_one_c\n        \n        #print(\"Top Roulette Outcome + Bottom Roulette Outcome\")\n        print(str(lucky_number_one) + \" + \" + str(lucky_number_one_c) + \" = \" + str(sum_n))\n        if sum_n %2==0:\n            print(\"OUTCOME: even\" )\n        else:\n            print(\"OUTCOME: odd\" )\n\n        plt.show()\n\nlucky = interact(fair,value = widgets.ToggleButton(\n        value=True,\n        description=\"Let's Play\",\n        disabled=False,\n        button_style='danger', # 'success', 'info', 'warning', 'danger' or ''\n        tooltip='Description',\n        icon='check'\n    ))\n\n### Question 5\n\nWe claim that this game is fair, but how can we verify it? \n\nRecall that a probability experiment is fair if every outcome is equally likely to occur. In order for this experiment to be fair, the probability of the event **even**  *must* be equal to the probability of event **odd**. \n\nWhat is the probability that the sum of the numbers in the top and bottom roulettes is even?\n\nfrom ipywidgets import interact_manual,widgets\n\ns = {'description_width': 'initial'}        \n@interact(answer =widgets.Select(\n                    options=[\"Select option\",\"1/2\",\\\n                            \"4/36\",\"1/3\",\\\n                             \"18/36\"],\n                    value='Select option',\n                    description=\"Probability sum is even\",\n                    disabled=False,\n                    style=s\n))\n\ndef fair_game(answer):\n    if answer==\"Select option\":\n        print(\"Click on the correct probability expressed as a fraction.\")\n    \n    elif answer==\"1/2\" or answer==\"18/36\":\n        print(\"Correct!\\nThere are a total of 36 possible outcomes. 18 out of 36 are even numbers.\\nThus the probability P(even) = 18/36 or 1/2. \")\n    elif answer != \"1/2\" or answer != \"Select Option\" or answer!=\"18/36\":\n        print(\"Hint: There are 36 entries in our sample space, each with equal likelihood of occurrence.\\nHow many of the 36 correspond to even numbers\")\n\n### Question 6\nWhat is the probability that the sum of the numbers in the top and bottom roulettes is odd? In other words, what is the probability that Bob will win?\n\nfrom ipywidgets import interact_manual,widgets\n\ns = {'description_width': 'initial'}        \n@interact(answer =widgets.Select(\n                    options=[\"Select option\",\"19/36\",\\\n                            \"17/36\",\"18/36\",\\\n                             \"1/2\"],\n                    value='Select option',\n                    description=\"Probability sum is odd\",\n                    disabled=False,\n                    style=s\n))\n\ndef fair_game(answer):\n    if answer==\"Select option\":\n        print(\"Click on the correct probability expressed as a fraction.\")\n    \n    elif answer==\"1/2\" or answer==\"18/36\":\n        print(\"Correct!\\nThere are a total of 36 possible outcomes. 18 out of 36 are odd numbers.\\nThus the P(odd) = 18/36 or 1/2. \")\n    elif answer != \"1/2\" or answer != \"Select Option\" or answer!=\"18/36\":\n        print(\"Hint: There are 36 entries in our sample space, each with equal likelihood of occurrence.\\nHow many of the 36 correspond to odd numbers?\")\n\nIn the section above we learned that the there are 18 out of 36 possible outcomes where the sum \n\n$$n_t + n_b$$\n\nis an even number. Thus\n\n$$P(even) = \\dfrac{18}{36} = \\dfrac{1}{2}$$\n\nSimilarly, there are 18 out of 36 possible outcomes where the sum\n\n$$n_t + n_b$$\n\nis an odd number. Thus\n\n$$P(odd) = \\dfrac{18}{36} = \\dfrac{1}{2}$$\n\nThen $P(odd) = P(even)$. With this we verify that indeed the experiment is fair. \n\n<h2 align='center'>Theoretical vs Experimental Probability</h2>\n\n\n\nWe begin by stating a few definitions. \n\n<div class=\"alert alert-warning\">\n    <font color=\"black\"><b>Definition.</b> The <i>Theoretical Probability</i> of an event $A$, denoted $P_T(A)$, is the ratio of the number of outcomes corresponding to this event to the number of possible outcomes. </font>\n</div>\n\n$$P_T(A) = \\dfrac{\\text{Total Number of Instances of event A in the Sample Space}}{\\text{Total Number of Possible Outcomes}}$$\n\nIf we take our fair experiment with two roulettes and sample space parity of outcome sum $\\lbrace \\text{even}, \\text{odd} \\rbrace$, the theoretical probability of an even event is\n\n$$P_T(\\text{even}) = \\dfrac{18}{36}$$\n\n<div class=\"alert alert-warning\">\n<font color=\"black\"><b>Definition.</b> The <i>Experimental Probability</i> of an event $A$, denoted $P_E(A)$, is computed over running the probability experiment a number of times and computing the observed ratio between the number of time the event occured  and the number of trials of the experiment. </font>\n</div>\n\n$$P_E(A) = \\dfrac{\\text{Number of Times Event A Actually Occurred}}{\\text{Number of trials}}$$\n\nIn order to determine $P_E(\\text{even})$, we first need to spin the roulettes a few times and compare.\n\nUse the widget below to simulate spinning the two roulettes. Use the slider to set a number of trials. In this interactive exercise, you can set number of trials as an integer between 1 and 100. Press `Run Interact` to run an experiment for the given number of trials.\n\nOn the right hand side you will find a printed message outlining the experimental probability of each event: Sum is Even and Sum is Odd from the number of trial specified using the widget. \n\nOn the left hand side you can find a graph comparing both. \n\nPress the `Run Interact` button several times. \n\n%matplotlib inline\n\ndef die(number):\n    count_A,count_C = 0,0\n    \n    for i in range(number):\n        lucky_number_one = random.choice([1,2,3,4,5,6])\n        lucky_number_two = random.choice([1,2,3,4,5,6])\n        if lucky_number_one - lucky_number_two >=0:\n            count_A +=1\n        else:\n            count_C +=1\n            \n    return [count_A,count_C]\n\ndef even_sum(number):\n    count_A,count_C = 0,0\n    \n    for i in range(number):\n        lucky_number_one = random.choice([1,2,3,4,5,6])\n        lucky_number_two = random.choice([1,2,3,4,5,6])\n        \n        sum_n = lucky_number_one + lucky_number_two\n        if  sum_n%2 == 0:\n            count_A +=1\n        else:\n            count_C +=1\n            \n    return [count_A,count_C]\n\ndef experimental_prob(number):\n    [varoi_1,varoi_2] = even_sum(number)\n    fig,(ax1,ax2,ax3) = plt.subplots(1,3,sharey=True,figsize=(15,4))\n\n    ax2.axis(\"Off\")\n    ax3.axis(\"Off\")\n    axalpha = 0.05\n    \n    even = varoi_1/number\n    odd = varoi_2/number\n    \n    labels = ['', '',  'Even Sum', '','Odd Sum']\n\n    ax1 = plt.subplot(131,facecolor=\"white\")\n    ax1.set_title(\"Experimental Probability\",fontsize=20)\n    ax1.set_ylabel(\"Probability\",fontsize=15)\n    ax1.set_xlabel(\"Outcomes\",fontsize=15)\n    ax1.set_xlim([0,3])\n\n    ax1.set_xticklabels(labels)\n\n    x = np.arange(1,3)\n    f1,f2= ax1.bar(x,[even,odd])\n    f1.set_facecolor(\"#8642f4\")\n    f2.set_facecolor(\"#518900\")\n\n    ax1.grid(which='both')\n    ax1.grid(b=True,which='minor',alpha=0.2,linestyle='--',color='black')\n    ax1.grid(which='major', alpha=0.2,linestyle='--',color='black')\n    \n    ax3 = plt.subplot(132)\n    ax3.axis(\"Off\")\n    \n    #ax3.set_title( \"Positive vs Negative\\nLuck Roulette: Outcome\",fontsize=20)\n    rec1 = Rectangle((0.1,0.8),0.3,0.1,facecolor=\"#8642f4\")\n    ax3.add_patch(rec1)\n    ax3.text(0.5,0.83,\"Experimental Probability: Sum is Even\",fontsize=20)\n    rec2 = Rectangle((0.1,0.7),0.3,0.1,facecolor=\"#518900\")\n    ax3.add_patch(rec2)\n    ax3.text(0.5,0.73,\"Experimental Probability: Sum is Odd\",fontsize=20)\n\n    ax2 = plt.subplot(133,facecolor=\"white\")\n    ax2.axis(\"Off\")\n\n    ax2.text(0.9,0.83,str(varoi_1) + \"/\" + str(number),fontsize=20)\n    ax2.text(0.9,0.73,str(varoi_2) + \"/\" + str(number),fontsize=20)\n    \n    ax3.set_title(\"                   Even or Odd Sum Experiment:\\n\",fontsize=20)\n    \n    plt.show()\n    \ndef run_fair_exp(number):\n    experimental_prob(number)\n    #experimental_prob(number,\"Negative\")\ninteract_manual(experimental_prob,number=widgets.IntSlider(\n            value=10,\n            min=1,\n            max=100,\n            step=1,\n            description='Total Number of Trials',\n            disabled=False,\n            continuous_update=False,\n            orientation='horizontal',\n            readout=True,\n            readout_format='d',\n            style =style\n));\n\n### Question 7\n\nUse the box below to enter your observations. \n\nHow do the experimental probabilities of each event change as you increase the number of trials?\n\nfrom ipywidgets import widgets as w\nfrom ipywidgets import Button, Layout\nfrom IPython.display import display, Javascript, Markdown\n\ndef rerun_cell( b ):    \n    display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1,IPython.notebook.get_selected_index()+2)'))   \n\nstyle = {'description_width': 'initial'}\n\nquestion7_text = w.Textarea( value='', placeholder='Write your answer here. Press Record Answer when you finish.', description='', disabled=False , layout=Layout(width='100%', height='75px') )\nquestion7_button = w.Button(button_style='info',description=\"Record Answer\", layout=Layout(width='15%', height='30px'))\n\ndisplay(question7_text)\ndisplay(question7_button)\n\nquestion7_button.on_click( rerun_cell ) \n\nquestion7_input = question7_text.value\n\nif(question7_input != ''):\n    question7_text.close()\n    question7_button.close()\n    display(Markdown(\"### Your answer for Question 7: Conclusions\"))\n    display(Markdown(question7_input))\n\n**Remarks**\n\nWe observe that every time we press the `Run Interact` button on the interactive above, the experimental probability of each event varies. However, it seems like as we increase the number of trials, the experimental probabilities of each event approach $1/2$. \n\nLet us explore what happens if we increase the number of trials to, say 10,000. \n\nIn the widget below you can find a slider that allows you to control the number of trials. In this interactive exercise, you can set number of trials as an integer between 1 and 10,000. \n\nOn the left hand side you can find a plot like the one we explored above. On the right hand side you can find the theoretical probability of events Sum is Even and Sum is Odd. \n\nPress the `Run Interact` button. Increase the Total Number of Trials and press the `Run Interact` button multiple times. \n\ndef toss(number):\n    store_head = []\n    store_tail = []\n    other = []\n    for i in range(number):\n        toss_coin= random.choice(np.arange(2))\n        \n        if toss_coin==0:\n            store_head.append(toss_coin)\n        elif toss_coin==1:\n            store_tail.append(toss_coin)\n        \n    return [store_head,store_tail]\n\ndef plot_coin_experiment(number):\n    varoi = toss(number)\n    fig,ax = plt.subplots(figsize=(5,5))\n\n    ax.set_title(\"Distribution of Experimental Coin Flipping\",fontsize=35)\n    plt.ylabel(\"Frequency\",fontsize=25)\n    plt.xlabel(\"Heads or Tails\",fontsize=25)\n    plt.xticks(np.arange(2), ('Total Number of Heads', 'Total Number of Tails'))\n    plt.hist(varoi[0])\n    plt.hist(varoi[1])\n    plt.grid(which='both')\n    plt.grid(b=True,which='minor',alpha=0.2,linestyle='--',color='black')\n    plt.grid(which='major', alpha=0.2,linestyle='--',color='black')\n\ndef plot_die_experiment(number):\n    varoi = die(number)\n    theor_A = 21/36\n    theor_C = 15/36\n    #print(theor)\n    fig,(ax1,ax2) = plt.subplots(1,2,sharey=True,figsize=(15,8))\n    \n    # Experimental Probability\n    ax1.set_title(\"Experimental Distribution\",fontsize=25)\n    ax1.set_ylabel(\"Frequency\",fontsize=25)\n    ax1.set_xlabel(\"Outcomes\",fontsize=25)\n    ax1.set_xlim([0,3])\n\n    ax1.set_xticks([])\n\n    x = np.arange(1,3)\n    dice = [varoi[0]/number,varoi[1]/number]\n    f1,f2 = ax1.bar(x,dice)\n    f1.set_facecolor(\"#8642f4\")\n    f2.set_facecolor(\"#518900\")\n    ax1.grid(which='both')\n    ax1.grid(b=True,which='minor',alpha=0.2,linestyle='--',color='black')\n    ax1.grid(which='major', alpha=0.2,linestyle='--',color='black')\n    \n    # Theoretical Probability\n    ax2.set_title(\"Theoretical Distribution\",fontsize=25)\n    ax2.set_ylabel(\"Frequency\",fontsize=25)\n    ax2.set_xlabel(\"Outcomes\",fontsize=25)\n    x = np.arange(1,3)\n    dice_exp = [theor_A,theor_C]\n    f11,f21 = ax2.bar(x,dice_exp)\n    f11.set_facecolor(\"#8642f4\")\n    f21.set_facecolor(\"#518900\")\n\n    ax2.set_xlim([0,3])\n    \n    ax2.set_xticks([\"Even\",\"Odd\"])\n    \n    ax2.grid(which='both')\n    ax2.grid(b=True,which='minor',alpha=0.2,linestyle='--',color='black')\n    ax2.grid(b=True,which='major', alpha=0.2,linestyle='--',color='black')\n\n    plt.ylim(0,number)\n    \n    plt.show()\n    \ndef plot_fair_experiment(number):\n    [varoi_1,varoi_2] = even_sum(number)\n    theor_A = 18/36\n    theor_C = 18/36\n    \n    even = varoi_1/number\n    odd= varoi_2/number\n    x = np.arange(1,3)\n    \n    labels = ['', '',  'Even Sum', '','Odd Sum']\n    \n    fig,(ax1,ax2) = plt.subplots(1,2,sharey=True,figsize=(15,8))\n    \n    # Experimental Probability\n    ax1.set_title(\"Even or Odd Sum Probability Experiment:\\nExperimental Probability\",fontsize=20)\n    ax1.set_ylabel(\"Probability\",fontsize=25)\n    ax1.set_xlabel(\"Events\",fontsize=25)\n    ax1.set_xlim([0,3])\n    ax1.set_xticklabels(labels)\n    ax1.grid(which='major', alpha=0.2,linestyle='--',color='black')\n    \n    f1,f2 = ax1.bar(x,[even,odd])\n    f1.set_facecolor(\"#8642f4\")\n    f2.set_facecolor(\"#518900\")\n    \n    # Theoretical Probability\n    ax2.set_title(\"Even or Odd Sum Probability Experiment:\\nTheoretical Probability\",fontsize=20)\n    ax2.set_ylabel(\"Probability\",fontsize=25)\n    ax2.set_xlabel(\"Events\",fontsize=25)\n    ax2.set_xlim([0,3])\n    ax2.set_xticklabels(labels)\n    ax2.grid(b=True,which='major', alpha=0.2,linestyle='--',color='black')\n    \n    dice_exp = [theor_A,theor_C]\n    f11,f21 = ax2.bar(x,dice_exp)\n    f11.set_facecolor(\"#8642f4\")\n    f21.set_facecolor(\"#518900\")\n    \n    plt.ylim(0,1)\n    plt.show()\n\ninteract_manual(plot_fair_experiment,number=widgets.IntSlider(\n            value=5,\n            min=1,\n            max=10000,\n            step=1,\n            description='Total Number of Trials',\n            disabled=False,\n            continuous_update=False,\n            orientation='horizontal',\n            readout=True,\n            readout_format='d',\n            style =style\n));\n\n### Question 8\n\nHow does the experimental probability of each event change as we increase the number of trials? Use the textbox below to record your answers. \n\nfrom ipywidgets import widgets as w\nfrom ipywidgets import Button, Layout\nfrom IPython.display import display, Javascript, Markdown\n\ndef rerun_cell( b ):\n    \n    display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1,IPython.notebook.get_selected_index()+2)'))   \nstyle = {'description_width': 'initial'}\n\n\nquestion8_text = w.Textarea( value='', placeholder='Write your answer here. Press Record Answer when you finish.', description='', disabled=False , layout=Layout(width='100%', height='75px') )\nquestion8_button = w.Button(button_style='info',description=\"Record Answer\", layout=Layout(width='15%', height='30px'))\n\ndisplay(question8_text)\ndisplay(question8_button)\n\nquestion8_button.on_click( rerun_cell ) \n\nquestion8_input = question8_text.value\n\nif(question8_input != ''):\n    \n    question8_text.close()\n    question8_button.close()\n    display(Markdown(\"### Your answer for Question 8: Conclusions\"))\n    display(Markdown(question8_input))\n\nAs the number of trials increases, we observe that the experimental probability of each event approaches the corresponding theoretical probability. This is known as the \"Law of Large Numbers\".\n\n<h2 align='center'>Conclusion</h2>\n\nIn this notebook we learned what a probability experiment is, what the sample space, events and outcome associated to a given probability experiment are. We learned how to express probabilities as ratios, fractions and percents. \n\nWe learned what independent probability events are and introduced the concept of a fair game. \n\nWe learned what theoretical and experimental probability are and with the help of an interactive exercise, we learned that as the number of trials increases, experimental probability approaches theoretical probability. \n\n[![Callysto.ca License](https://github.com/callysto/curriculum-notebooks/blob/master/callysto-notebook-banner-bottom.jpg?raw=true)](https://github.com/callysto/curriculum-notebooks/blob/master/LICENSE.md)", "meta": {"hexsha": "0021580bc637d63a2188af2ebad94a8559153295", "size": 60645, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/curriculum-notebooks/Mathematics/ProbabilityExperiment/probability-experiment.py", "max_stars_repo_name": "BryceHaley/curriculum-jbook", "max_stars_repo_head_hexsha": "d1246799ddfe62b0cf5c389394a18c2904383437", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-18T18:19:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T18:19:40.000Z", "max_issues_repo_path": "_build/jupyter_execute/curriculum-notebooks/Mathematics/ProbabilityExperiment/probability-experiment.py", "max_issues_repo_name": "callysto/curriculum-jbook", "max_issues_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/curriculum-notebooks/Mathematics/ProbabilityExperiment/probability-experiment.py", "max_forks_repo_name": "callysto/curriculum-jbook", "max_forks_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.6231983528, "max_line_length": 615, "alphanum_fraction": 0.622079314, "include": true, "reason": "import numpy", "num_tokens": 16592, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3812195803163617, "lm_q2_score": 0.1732882016598637, "lm_q1q2_score": 0.0660608555105503}}
{"text": "# -*- coding: utf-8 -*-\n# ---\n# jupyter:\n#   '@webio':\n#     lastCommId: a8ab2762cccf499696a7ef0a86be4d18\n#     lastKernelId: 261999dd-7ee7-4ad4-9a26-99a84a77979b\n#   cite2c:\n#     citations:\n#       6202365/8AH9AXN2:\n#         URL: http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory.pdf\n#         author:\n#         - family: Carroll\n#           given: Christopher\n#         container-title: Manuscript, Department of Economics, Johns Hopkins University\n#         id: 6202365/8AH9AXN2\n#         issued:\n#           month: 2\n#           year: 2019\n#         note: \"Available at http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory\\\n#           \\ \\nCitation Key: carrollBufferStockTheory \\nbibtex*[extra=bibtex:carrollBufferStockTheory]\"\n#         title: Theoretical Foundations of Buffer Stock Saving\n#         type: article-journal\n#       6202365/TGG4U7J4:\n#         author:\n#         - family: Clarida\n#           given: Richard H.\n#         container-title: International Economic Review\n#         issued:\n#           date-parts:\n#           - - 1987\n#         page: \"339\\u2013351\"\n#         title: Consumption, Liquidity Constraints, and Asset Accumulation in the Face\n#           of Random Fluctuations in Income\n#         type: article-journal\n#         volume: XXVIII\n#       undefined:\n#         URL: http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory.pdf\n#         author:\n#         - family: Carroll\n#           given: Christopher\n#         container-title: Manuscript, Department of Economics, Johns Hopkins University\n#         issued:\n#           date-parts:\n#           - - '2019'\n#             - 2\n#         note: \"Available at http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory\\\n#           \\ \\nCitation Key: carrollBufferStockTheory \\nbibtex*[extra=bibtex:carrollBufferStockTheory]\"\n#         title: Theoretical Foundations of Buffer Stock Saving\n#         type: article-journal\n#   jupytext:\n#     formats: ipynb,py:percent\n#     text_representation:\n#       extension: .py\n#       format_name: percent\n#       format_version: '1.1'\n#       jupytext_version: 0.8.3\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n#   language_info:\n#     codemirror_mode:\n#       name: ipython\n#       version: 3\n#     file_extension: .py\n#     mimetype: text/x-python\n#     name: python\n#     nbconvert_exporter: python\n#     pygments_lexer: ipython3\n#     version: 3.6.7\n#   varInspector:\n#     cols:\n#       lenName: 16\n#       lenType: 16\n#       lenVar: 40\n#     kernels_config:\n#       python:\n#         delete_cmd_postfix: ''\n#         delete_cmd_prefix: 'del '\n#         library: var_list.py\n#         varRefreshCmd: print(var_dic_list())\n#       r:\n#         delete_cmd_postfix: ') '\n#         delete_cmd_prefix: rm(\n#         library: var_list.r\n#         varRefreshCmd: 'cat(var_dic_list()) '\n#     types_to_exclude:\n#     - module\n#     - function\n#     - builtin_function_or_method\n#     - instance\n#     - _Feature\n#     window_display: false\n# ---\n\n# %% [markdown]\n# # Buffer Stock Saving in HARK and dolo\n# <!-- <p style=\"text-align: center;\"><small><small>Generator: BufferStockTheory-make/notebooks_byname</small></small></p>\n# -->\n\n# %% [markdown]\n# This notebook compares the solutions to a standard buffer stock saving model obtained by the [Econ-ARK/HARK](https://github.com/econ-ark/HARK) toolkit and the [dolo](https://github.com/EconForge/dolo) modeling system.\n\n# %% {\"code_folding\": [0]}\n# This cell does some setup and imports generic tools \n\nGenerator=True # Is this notebook the master or is it generated?\n# Import related generic python packages\nimport numpy as np\nfrom time import clock\nmystr = lambda number : \"{:.4f}\".format(number)\n\n# This is a jupytext paired notebook that autogenerates BufferStockTheory.py\n# which can be executed from a terminal command line via \"ipython BufferStockTheory.py\"\n# But a terminal does not permit inline figures, so we need to test jupyter vs terminal\n# Google \"how can I check if code is executed in the ipython notebook\"\n\nfrom IPython import get_ipython # In case it was run from python instead of ipython\ndef in_ipynb():\n    try:\n        if str(type(get_ipython())) == \"<class 'ipykernel.zmqshell.ZMQInteractiveShell'>\":\n            return True\n        else:\n            return False\n    except NameError:\n        return False\n\n# Determine whether to make the figures inline (for spyder or jupyter)\n# vs whatever is the automatic setting that will apply if run from the terminal\nif in_ipynb():\n    # %matplotlib inline generates a syntax error when run from the shell\n    # so do this instead\n    get_ipython().run_line_magic('matplotlib', 'inline')\nelse:\n    get_ipython().run_line_magic('matplotlib', 'auto')\n    print('You appear to be running from a terminal')\n    print('By default, figures will appear one by one')\n    print('Close the visible figure in order to see the next one')\n\n# Import the plot-figure library matplotlib\n\nimport matplotlib.pyplot as plt\n\n# In order to use LaTeX to manage all text layout in our figures, we import rc settings from matplotlib.\nfrom matplotlib import rc\nplt.rc('font', family='serif')\n\n# LaTeX is huge and takes forever to install on mybinder\n# so if it is not installed then do not use it \nfrom distutils.spawn import find_executable\niflatexExists=False\nif find_executable('latex'):\n    iflatexExists=True\n    \nplt.rc('font', family='serif')\nplt.rc('text', usetex=iflatexExists)\n\n# The warnings package allows us to ignore some harmless but alarming warning messages\nimport warnings\nwarnings.filterwarnings(\"ignore\")\n\n# The tools for navigating the filesystem\nimport sys\nimport os\n\nsys.path.insert(0, os.path.abspath('../../lib')) # REMARKs directory is two down from root \n\nfrom HARK.utilities import plotFuncsDer, plotFuncs\nfrom copy import copy, deepcopy\n\n# Define (and create, if necessary) the figures directory \"Figures\"\nif Generator:\n    my_file_path = os.path.dirname(os.path.abspath(\"BufferStockTheory.ipynb\")) # Find pathname to this file:\n    Figures_HARK_dir = os.path.join(my_file_path,\"Figures/\") # LaTeX document assumes figures will be here\n    Figures_HARK_dir = os.path.join(my_file_path,\"/tmp/Figures/\") # Uncomment to make figures outside of git path\n    if not os.path.exists(Figures_HARK_dir):\n        os.makedirs(Figures_HARK_dir)\n\n# %% [markdown]\n# ## [The Problem](http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/#The-Problem) \n#\n# [This paper](http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/#The-Problem) defines a buffer stock saving model and calibrates parameters:\n#\n# | Parameter | Description | Code | Value |\n# | :---: | ---         | ---  | :---: |\n# | $\\newcommand{\\PermGroFac}{\\Gamma}\\PermGroFac$ | Permanent Income Growth Factor | $\\texttt{PermGroFac}$ | 1.03 |\n# | $\\newcommand{\\Rfree}{\\mathrm{\\mathsf{R}}}\\Rfree$ | Interest Factor | $\\texttt{Rfree}$ | 1.04 |\n# | $\\newcommand{\\DiscFac}{\\beta}\\DiscFac$ | Time Preference Factor | $\\texttt{DiscFac}$ | 0.96 |\n# | $\\newcommand{\\CRRA}{\\rho}\\CRRA$ | Coefficient of Relative Risk Aversion| $\\texttt{CRRA}$ | 2 |\n# | $\\newcommand{\\UnempPrb}{\\wp}\\UnempPrb$ | Probability of Unemployment | $\\texttt{UnempPrb}$ | 0.005 |\n# | $\\newcommand{\\IncUnemp}{\\mu}\\IncUnemp$ | Income when Unemployed | $\\texttt{IncUnemp}$ | 0. |\n# | $\\newcommand{\\PermShkStd}{\\sigma_\\psi}\\PermShkStd$ | Std Dev of Log Permanent Shock| $\\texttt{PermShkStd}$ | 0.1 |\n# | $\\newcommand{\\TranShkStd}{\\sigma_\\theta}\\TranShkStd$ | Std Dev of Log Transitory Shock| $\\texttt{TranShkStd}$ | 0.1 |\n#\n# For a microeconomic consumer with 'Market Resources' (net worth plus current income) $M_{t}$, end-of-period assets $A_{t}$ will be the amount remaining after consumption of $C_{t}$.  <!-- Next period's 'Balances' $B_{t+1}$ reflect this period's $A_{t}$ augmented by return factor $R$:-->\n# \\begin{eqnarray}\n# A_{t}   &=&M_{t}-C_{t}  \\label{eq:DBCparts} \\\\\n# %B_{t+1}   & = & A_{t} R \\notag \\\\\n# \\end{eqnarray}\n#\n# The consumer's permanent noncapital income $P$ grows by a predictable factor $\\PermGroFac$ and is subject to an unpredictable lognormally distributed multiplicative shock $\\mathbb{E}_{t}[\\psi_{t+1}]=1$, \n# \\begin{eqnarray}\n# P_{t+1} & = & P_{t} \\PermGroFac \\psi_{t+1}\n# \\end{eqnarray}\n#\n# and actual income is permanent income multiplied by a logormal multiplicative transitory shock, $\\mathbb{E}_{t}[\\theta_{t+1}]=1$, so that next period's market resources are\n# \\begin{eqnarray}\n# %M_{t+1} &=& B_{t+1} +P_{t+1}\\theta_{t+1},  \\notag\n# M_{t+1} &=& A_{t}R +P_{t+1}\\theta_{t+1}.  \\notag\n# \\end{eqnarray}\n#\n# When the consumer has a CRRA utility function $u(c)=\\frac{c^{1-\\rho}}{1-\\rho}$, the paper shows that the problem can be written in terms of ratios of money variables to permanent income, e.g. $m_{t} \\equiv M_{t}/P_{t}$, and the Bellman form of [the problem reduces to](http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/#The-Related-Problem):\n#\n# \\begin{eqnarray*}\n# v_t(m_t) &=& \\max_{c_t}~~ u(c_t) + \\beta~\\mathbb{E}_{t} [(\\Gamma\\psi_{t+1})^{1-\\rho} v_{t+1}(m_{t+1}) ] \\\\\n# & s.t. & \\\\\n# a_t &=& m_t - c_t \\\\\n# m_{t+1} &=& R/(\\Gamma \\psi_{t+1}) a_t + \\theta_{t+1} \\\\\n# \\end{eqnarray*}\n#\n# and the Euler equation for this model is \n#\n# \\begin{eqnarray*}\n# c_{t}^{-\\rho} & = & R \\beta \\mathbb{E}_{t}[(\\Gamma \\psi c_{t+1})^{-\\rho})] \\\\\n# 0 & = & R \\beta \\mathbb{E}_{t}[(\\Gamma \\psi c_{t+1}/c_{t})^{-\\rho})]-1\n# \\end{eqnarray*}\n#\n#\n# For the purposes of this notebook, the paper's baseline parameterization is changed as follows:\n#\n# 1. The unemployment (zero-income event) shocks are turned off\n# 2. An explicit liqudity constraint is added ($c_{t} \\leq m_{t}$)\n\n# %% [markdown]\n# # Dolo\n#\n# [Installation instructions](https://github.com/EconForge/dolo/wiki/Installation) for dolo involve a number of dependencies, including the dolo language \"dolang.\"  This notebook assumes all these have been installed.\n\n# %%\nfrom dolo import *\n\n# %% [markdown]\n# Dolo defines models using \"model files\" whose syntax is specified in the documentation\n\n# %%\nmodel_dolo = yaml_import(\"../models/bufferstock.yaml\")\nprint( model_dolo )\n\n# %%\n# Set a maximum value of the market resources ratio m for use in both models\nmax_m = 500\nmodel_dolo.data['calibration']['max_m'] = max_m\nmodel_dolo.data['domain']['m'] = [0,'max_m']\n\n# Obtain the decision rule by time iteration\ndr = time_iteration(model_dolo,tol=1e-08,verbose=True)\n\n# %% [markdown]\n# # HARK\n# The HARK tool used here is $\\texttt{ConsIndShockModel.py}$.  For an introduction to this module, see the [ConsIndShockModel.ipynb](https://econ-ark.org/notebooks) notebook at the [Econ-ARK](https://econ-ark.org) website.\n\n# %% {\"code_folding\": [0]}\n# Define a parameter dictionary with baseline parameter values\n\n# Set the baseline parameter values \nPermGroFac = 1.03\nRfree      = 1.04\nDiscFac    = 0.96\nCRRA       = 2.00\nUnempPrb   = 0.00\nIncUnemp   = 0.0\nPermShkStd = 0.1\nTranShkStd = 0.1\n# Import default parameter values\nimport HARK.ConsumptionSaving.ConsumerParameters as Params \n\n# Make a dictionary containing all parameters needed to solve the model\nbase_params = Params.init_idiosyncratic_shocks\n\n# Set the parameters for the baseline results in the paper\n# using the variable values defined in the cell above\nbase_params['PermGroFac'] = [PermGroFac]   # Permanent income growth factor\nbase_params['Rfree']      = Rfree          # Interest factor on assets\nbase_params['DiscFac']    = DiscFac        # Time Preference Factor\nbase_params['CRRA']       = CRRA           # Coefficient of relative risk aversion\nbase_params['UnempPrb']   = UnempPrb       # Probability of unemployment (e.g. Probability of Zero Income in the paper)\nbase_params['IncUnemp']   = IncUnemp       # Induces natural borrowing constraint\nbase_params['PermShkStd'] = [PermShkStd]   # Standard deviation of log permanent income shocks\nbase_params['TranShkStd'] = [TranShkStd]   # Standard deviation of log transitory income shocks\n\n# Some technical settings that are not interesting for our purposes\nbase_params['LivPrb']       = [1.0]   # 100 percent probability of living to next period\nbase_params['CubicBool']    = True    # Use cubic spline interpolation\nbase_params['T_cycle']      = 1       # No 'seasonal' cycles\nbase_params['BoroCnstArt']  = None    # No artificial borrowing constraint\n\nfrom HARK.utilities import plotFuncsDer, plotFuncs\nfrom HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n# %%\n# Create a model identical to the dolo model\n# Start with the HARK baseline parameters and modify \n# to be like the dolo model \nbase_params_dolo = dict(base_params)\nbase_params_dolo['BoroCnstArt']  = 0.0    # Liquidity constraint at 0\nbase_params_dolo['UnempPrb']     = 0      # No point-mass on unemployment state \nbase_params_dolo['TranShkCount'] = 5      # Default number of nodes in dolo\nbase_params_dolo['PermShkCount'] = 5\nbase_params_dolo['aXtraMax']     = max_m  # Use same maximum\nbase_params_dolo['aXtraCount']   = 100    # How dense to make the grid\nbase_params_dolo['DiscFac']      = 0.96\n#base_params_dolo['CubicBool']    = False\nmodel_HARK = IndShockConsumerType(**base_params_dolo,cycles=0) # cycles=0 indicates infinite horizon\n\n# %%\n# Solve the HARK model \nmodel_HARK.updateIncomeProcess()\nmodel_HARK.solve()\nmodel_HARK.UnempPrb = 0.05\nmodel_HARK.unpackcFunc()\n\n# %%\n\n# Plot the results: Green is perfect foresight, red is HARK, black is dolo\ntab = tabulate(model_dolo, dr, 'm')\nplt.plot(tab['m'],tab['c'])     # This is pretty cool syntax\nm = tab.iloc[:,2]\nc_m  = model_HARK.cFunc[0](m)   \n# cPF uses the analytical formula for the perfect foresight solution\ncPF = (np.array(m)-1+1/(1-PermGroFac/Rfree))*((Rfree-(Rfree * DiscFac)**(1/CRRA))/Rfree)\nplt.plot(tab['m'],c_m,color=\"red\")\nplt.plot(m,cPF,color=\"green\")\n", "meta": {"hexsha": "e340d2a8695ccbb8f30f4fbf001bac338ff6224e", "size": 13765, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/notebooks/BufferStock-HARK-vs-dolo.py", "max_stars_repo_name": "iworld1991/dolo", "max_stars_repo_head_hexsha": "d70ccbe1254c8fc9a4fb8b0f7f2524140deebaf5", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/notebooks/BufferStock-HARK-vs-dolo.py", "max_issues_repo_name": "iworld1991/dolo", "max_issues_repo_head_hexsha": "d70ccbe1254c8fc9a4fb8b0f7f2524140deebaf5", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/notebooks/BufferStock-HARK-vs-dolo.py", "max_forks_repo_name": "iworld1991/dolo", "max_forks_repo_head_hexsha": "d70ccbe1254c8fc9a4fb8b0f7f2524140deebaf5", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.4608433735, "max_line_length": 354, "alphanum_fraction": 0.6852887759, "include": true, "reason": "import numpy", "num_tokens": 4006, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4882833952958347, "lm_q2_score": 0.134775915685312, "lm_q1q2_score": 0.06580884171492929}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# In[1]:\n\n\nimport os\nfrom sympy import *\nimport pandas as pd\nimport numpy as np\nimport scipy.fftpack\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nplt.style.use(\"seaborn-paper\")\n\ndef find_nearest(array, value):\n    array = np.asarray(array)\n    idx = (np.abs(array - value)).argmin()\n    return idx\n\n\n# ## Canvas palette\n\n# In[2]:\n\n\n#Canvas for single plot\nx = np.linspace(0,10,100)\ny = np.sin(x)\nplt.figure(figsize=[14,6])\nplt.grid(True)\nplt.title(\"Change-me!\",fontsize=20)\nplt.plot(x,y,label=\"testvalue\")\nplt.legend(fontsize=16)\nplt.xlabel(\"XLABEL (unit)\",fontsize=18)\nplt.ylabel(\"YLABEL (unit)\",fontsize=18)\nplt.show()\n\n\n# In[3]:\n\n\n#Canvas for side by side\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(14,6))\nfig.suptitle(\"test\",y=1.05,fontsize=20)\n\naxes[0].grid(True)\naxes[0].plot(x,y,label=\"testvalue\")\naxes[0].legend(fontsize=16)\naxes[0].set_title(\"TESTTITLE\",fontsize=18)\naxes[0].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[0].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[0].legend(fontsize=16)\naxes[0].tick_params(axis='both', which='major', labelsize=15)\n\n\naxes[1].grid(True)\naxes[1].plot(x,y,label=\"testvalue\")\naxes[1].legend(fontsize=16)\naxes[1].set_title(\"TESTTITLE\",fontsize=18)\naxes[1].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[1].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[1].legend(fontsize=16)\naxes[1].tick_params(axis='both', which='major', labelsize=15)\n\nfig.tight_layout()\nplt.show()\n\n\n# In[4]:\n\n\n#Canvas for side by side\nfig, axes = plt.subplots(nrows=2, ncols=4, figsize=(14,6))\nfig.suptitle(\"test\",y=1.05,fontsize=20)\n\naxes[0,0].grid(True)\naxes[0,0].plot(x,y,label=\"testvalue\")\naxes[0,0].legend(fontsize=16)\naxes[0,0].set_title(\"TESTTITLE\",fontsize=18)\naxes[0,0].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[0,0].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[0,0].legend(fontsize=16)\naxes[0,0].tick_params(axis='both', which='major', labelsize=15)\n\n\naxes[0,1].grid(True)\naxes[0,1].plot(x,y,label=\"testvalue\")\naxes[0,1].legend(fontsize=16)\naxes[0,1].set_title(\"TESTTITLE\",fontsize=18)\naxes[0,1].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[0,1].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[0,1].legend(fontsize=16)\naxes[0,1].tick_params(axis='both', which='major', labelsize=15)\n\nfig.tight_layout()\nplt.show()\n\n\n# ## Read data\n\n# In[5]:\n\n\n#Folder and paths definitions\nmain_path  = os.getcwd()\ndatafolder_path = main_path+\"/results\"\nresults_dir = \"/output_py\" \noutput_dir = main_path+results_dir\ntry:\n    os.mkdir(output_dir)\nexcept OSError:\n    print (\"Creation of the directory %s failed\" % results_dir)\nelse:\n    print (\"Successfully created the directory %s \" % results_dir)\n\n\n# In[ ]:\n\n\n\n\n\n# In[6]:\n\n\n#Simulation parameters\nN = 5000\nT = 10000\nn_runs = 20\ndt = .01\nfreq = \"gfreq\"\nMF = \"MF\"\n\nif(freq ==\"gfreq\"):\n    freq_plot=\"$\\\\mathcal{N}(0,1)$ natural freqs\"\nelse:\n    freq_plot=\"Uniformly distributed freqs $\\\\in[-.5,.5]$\"\nif(MF ==\"MF\"):\n    MF_plot=\"MeanField\"\nelse:\n    MF_plot=\"non-MeanField\"\n\n\n# In[13]:\n\n\n#OutputFileNames\n#S/N --> |r(t)|/sigma(r(t))\nsn_name = \"S_N\"\n#(Mod&Phase)(t)\nmodphase_name = \"ModPhase_t\"\n#Spectrum\nspectrum_name = \"Spectrum\"\n#r_inf\nrinf_name = \"r_inf\"\n#Configuration-specific name\nconfig_name= \"/N%d_nruns%d_freq=%s_\"%(N,n_runs,freq)\n\n\n# In[19]:\n\n\n#K for simulation\nK_r0 = np.arange(0,1.4,.2) #da 0 a 1.2 a step di .2, note the last step is not included!\nK_r1 = np.arange(1.21,2.01,.01)\nK_r2 = np.arange(2.1,5.1,.1)\nKvalues = np.concatenate((K_r0,K_r1,K_r2))\nKvalues = np.unique(Kvalues, axis=0)\nprint(len(Kvalues))\nKvalues\n\n\n# In[9]:\n\n\n#Create dataframe dictionary. For each entry, first value is the K of the dataframe (second value)\ndata = []\nfor i in range(0,len(Kvalues)):\n    filename = datafolder_path + \"/%s_uphase_N%d_%s_T%d_dt%.4f_nruns%d_K%.3f.tsv\"%(freq,N,MF,T,dt,n_runs,Kvalues[i])\n    #cols refers to timestep, avgmod, stdmod, avgphase,stdphase (of order parameter)\n    df = pd.read_csv(filename,sep=\"\\t\",header=None)\n    data.append([format(Kvalues[i],'.3f'),df])\n\n\n# In[ ]:\n\n\n\n\n\n# ## Plots\n\n# In[18]:\n\n\n#Plot settings\nalph = 1\ntmax =100\n\nselected_index = [0,3,17,21,25,47]\nfig = plt.figure(figsize=[14,6])\nplt.grid(True)\nplt.title(\"N = %d, dt = %.3f, %s, n_runs = %d\" % (N,dt,freq_plot,n_runs),fontsize=20)\nfor i in selected_index:\n    plt.plot(data[i][1][0],data[i][1][1]/data[i][1][2],ls='--',marker='.',markersize=.5,label=\"K=%s\"%(data[i][0]),alpha=alph)\n    plt.semilogy()\n    plt.legend(fontsize=16)\nplt.xlabel(\"t\",fontsize=18)\nplt.ylabel(\"$\\\\frac{|r(t)|}{\\\\sigma(r(t))}$\",fontsize=20,rotation=0)\nplt.xlim(0,tmax)\n\nfig.tight_layout()\nplt.savefig(output_dir+config_name+sn_name)\nplt.show()\n\n\n# In[11]:\n\n\n#Plot settings\nalph = 1\ntmax =80\n\n\nfig, axes = plt.subplots(nrows=2, ncols=1, figsize=(14,6))\n\nfig.suptitle(\"N = %d, dt = %.3f, %s, n_runs = %d\"%(N,dt,freq_plot, n_runs),y=.95,fontsize=20)\n\naxes[0].grid(True)\n\nfor i in selected_index:\n    axes[0].errorbar(data[i][1][0],data[i][1][1],yerr=data[i][1][2],ls='--',linewidth=.5,fmt='.',markersize=.05, elinewidth=.5, capthick=.5,label=\"K=%s\"%(data[i][0]),alpha=alph)\n    axes[1].errorbar(data[i][1][0],data[i][1][3],yerr=data[i][1][4],ls='--',linewidth=.5,fmt='.',markersize=.05, elinewidth=.5, capthick=.5,label=\"K=%s\"%(data[i][0]),alpha=alph)\n\naxes[0].legend(fontsize=16)\naxes[0].set_title(\"|r(t)|\",fontsize=18)\naxes[0].set_xlabel(\"t\",fontsize=18)\naxes[0].set_ylabel(\"\",fontsize=18)\naxes[0].legend(fontsize=16,ncol=2)\naxes[0].set_xlim(0,tmax)\naxes[0].tick_params(axis='both', which='major', labelsize=15)\n\n\naxes[1].grid(True)\naxes[1].legend(fontsize=16)\naxes[1].set_title(\"Arg(r(t))\",fontsize=18)\naxes[1].set_xlabel(\"t\",fontsize=18)\naxes[1].set_ylabel(\"\",fontsize=18)\naxes[1].legend(fontsize=16,ncol=2)\naxes[1].set_xlim(0,tmax)\naxes[1].tick_params(axis='both', which='major', labelsize=15)\nfig.tight_layout()\n\nplt.subplots_adjust(top=.85)\nplt.savefig(output_dir+config_name+modphase_name)\nplt.show()\n\n\n# In[12]:\n\n\nmax_K_in_plot = 8\nmax_n_of_K_in_plot = 5\nidx_max_K_in_plot = find_nearest(Kvalues,max_K_in_plot)\n\nfig, axes = plt.subplots(nrows=2, ncols=3, figsize=(14,6))\nfig.suptitle(\"$\\\\mathcal{F}(r(t))$,\\nN = %d, dt = %.3f, %s, n_runs = %d\"%(N,dt,freq_plot, n_runs),y=1,fontsize=20)\ncounter1 = 0\ncounter2 = 0\nfor i in selected_index:\n    if(counter1<len(selected_index)/2):\n        axes[0,counter1].grid(True)\n        im = axes[0,counter1].specgram(data[i][1][1],Fs=1/dt)\n        axes[0,counter1].set_title(\"K = %s\"%(data[i][0]),fontsize=18)\n        axes[0,counter1].set_xlabel(\"t\",fontsize=18)\n        axes[0,counter1].set_ylabel(\"Freq.\",fontsize=18)\n        axes[0,counter1].tick_params(axis='both', which='major', labelsize=15)\n        counter1 = counter1+1\n    else:  \n        axes[1,counter2].grid(True)\n        im = axes[1,counter2].specgram(data[i][1][1],Fs=1/dt)\n        axes[1,counter2].set_title(\"K = %s\"%(data[i][0]),fontsize=18)\n        axes[1,counter2].set_xlabel(\"t\",fontsize=18)\n        axes[1,counter2].set_ylabel(\"Freq.\",fontsize=18)\n        axes[1,counter2].tick_params(axis='both', which='major', labelsize=15)\n        counter2 = counter2+1\n\nfig.tight_layout()\nplt.subplots_adjust(top=.85)\n\nplt.savefig(output_dir+config_name+spectrum_name)\n\nplt.show()\n\n\n# In[20]:\n\n\n#for r_inf evaluation\nKval_list = []\nr_inf = []\nr_inf_err = []\nlast_percent = .9\nfor i in range(0,len(Kvalues)):\n    r_inf.append([np.mean(data[i][1][1][int(len(data[i][1][1])*last_percent):])])\n    r_inf_err.append([np.std(data[i][1][1][int(len(data[i][1][1])*last_percent):])])\n    Kval_list.append([Kvalues[i]])\n\n\n# # ADD ERRORBARS\n\n# In[ ]:\n\n\n\nfig = plt.figure(figsize=[14,6])\nplt.grid(True)\nplt.title(\"N = %d, dt = %.3f, %s, n_runs = %d\"%(N,dt,freq_plot, n_runs),y=1,fontsize=20)\n#plt.errorbar(Kval_list,r_inf,y_err=r_inf_err,label=\"testvalue\")\nplt.errorbar(Kval_list,r_inf,ls='--',linewidth=.5,fmt='.',markersize=5, elinewidth=.5, capthick=.5,label=\"Average on last %d steps\"%((1-last_percent)*T+1))\nplt.legend(fontsize=16)\nplt.xlabel(\"K\",fontsize=18)\nplt.ylabel(\"$r_{\\\\infty}$\",fontsize=18,rotation=0)\n\nfig.tight_layout()\nplt.savefig(output_dir+config_name+rinf_name)\n\nplt.show()\n\n\n\n\n", "meta": {"hexsha": "ad838cfa1f6c86ea2cb39dc13df1710e9a5c6d1d", "size": 8071, "ext": "py", "lang": "Python", "max_stars_repo_path": "Code/Python/Main_analysis.py", "max_stars_repo_name": "spicella/Intro_to_ComplexSystems-Kuramoto", "max_stars_repo_head_hexsha": "64c027f1f0d16b2358d6889de453c1474d3dea6b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-01-04T22:36:10.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-04T22:36:10.000Z", "max_issues_repo_path": "Code/Python/Main_analysis.py", "max_issues_repo_name": "spicella/Intro_to_ComplexSystems-Kuramoto", "max_issues_repo_head_hexsha": "64c027f1f0d16b2358d6889de453c1474d3dea6b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-01-01T16:13:24.000Z", "max_issues_repo_issues_event_max_datetime": "2020-01-01T16:13:24.000Z", "max_forks_repo_path": "Code/Python/Main_analysis.py", "max_forks_repo_name": "spicella/IntroCS-Kuramoto", "max_forks_repo_head_hexsha": "64c027f1f0d16b2358d6889de453c1474d3dea6b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.1646706587, "max_line_length": 177, "alphanum_fraction": 0.6740180895, "include": true, "reason": "import numpy,import scipy,from sympy", "num_tokens": 2725, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3886180267058489, "lm_q2_score": 0.16885695214168314, "lm_q1q2_score": 0.06562085553686486}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Recomendation system : Book Recommendation \n\n# ### Oleh : [Ahmad Habib Husaini](https://www.linkedin.com/in/ahmad-habib-husaini-1705711b0/)\n# \n# #### Pendahuluan\n# Pada proyek ini, topik yang dibahas adalah mengenai pembuatan sistem rekomendasi dengan data book . Proyek ini dibuat untuk proyek Submission 2 - Machine Learning Terapan Dicoding.\n\n# # 1. Import important package\n\n# In[1]:\n\n\nimport pandas as pd \nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport opendatasets\nimport wget\nimport zipfile\nfrom tqdm import tqdm\nimport os\n\n\n# # 2. Data loading\n\n# ## 2.1 Data Acquisition\n\n# In[2]:\n\n\nif os.path.exists('book-recommendation-dataset'):\n    print(\"file sudah ada\")\nelse:\n    opendatasets.download_kaggle_dataset(dataset_url='https://www.kaggle.com/arashnic/book-recommendation-dataset', data_dir='')\n\n\n# Pada tahapan *data loading* berisikan akuisisi data dengan mengunduh dataset pada [link](https://www.kaggle.com/arashnic/book-recommendation-dataset) dengan menggunakan library `opendatasets` dengan sintaks seperti diatas. Ketika merunning code tersebut akan diminta mengisikan username dan key. \n# 1. username silahkan disisi dengan username *account* kaggle\n# 2. key didapatkan dengan :\n#     1. Buka website [kaggle](https://www.kaggle.com/), \n#     2. login dengan akun masing-masing. \n#     3. Pilih your profile pada kanan atas \n#     4. Pilih *account*\n#     5. Scroll sedikit kebawah maka akan ada pilihan `Create new API token`\n#     <img src=\"image/kaggle_token.png\" style=\"zoom:5%;\" /> <br>\n#     6. Setelah menekan pilihan tersebut akan terunduh file kaggle.json yang berisikan username dan key\n\n# ## 2.2 Memuat data dalam format Dataframe\n\n# ### 2.2.1 Book Dataframe \n\n# In[3]:\n\n\ndf_book = pd.read_csv('book-recommendation-dataset/Books.csv')\ndf_book.head(3)\n\n\n# ### 2.2.2 Rating Dataframe\n\n# In[4]:\n\n\ndf_rating = pd.read_csv('book-recommendation-dataset/Ratings.csv')\ndf_rating.head(3)\n\n\n# ### 2.2.4 User Dataframe\n\n# In[5]:\n\n\ndf_user = pd.read_csv('book-recommendation-dataset/Users.csv')\ndf_user.tail(3)\n\n\n# # 3. Data Understanding\n\n# ## 3.1 Informasi dataset\n\n# ![image/kaggle_dataset.png](attachment:image.png)<br>\n# Pada berkas yang dapat diunduh pada link [berikut](https://www.kaggle.com/arashnic/book-recommendation-dataset?select=Users.csv) berisikan dataset berjumlah 3 buah file yakni Book.csv, Rating.csv dan User.csv\n# \n\n# ### 3.1.1 Book\n# \n# Berisikan data sebanyak 271360 baris dan 8 kolom yang terdiri dari: <br>\n# \n# Kolom  | Keterangan\n# :------------- | :-------------\n# Sumber  | https://www.kaggle.com/arashnic/book-recommendation-dataset?select=Books.csv\n# ISBN | International Standard Book Number merupakan kode unik masing masing buku\n# Book-title | Merupakan judul dari tiap buku\n# Book-Author | Merupakan penulis atau pengarang tiap buku\n# Year-Of_Publication |Merupakan tahun terbit tiap buku\n# Publisher | Merupakan lebaga penerbit tiap buku\n# Image-URL-S | Link foto dari tiap buku berukuran kecil\n# Image-URL-M | Link foto dari tiap buku berukuran sedang\n# Image-URL-L | Link foto dari tiap buku berukuran besar\n\n# ### 3.1.2 Rating\n# Berisikan data sebanyak 1149780 baris dan 3 kolom yang terdiri dari:\n# \n# Kolom  | Keterangan\n# :------------- | :-------------\n# Sumber  | https://www.kaggle.com/arashnic/book-recommendation-dataset?select=Ratings.csv\n# User-ID | Merupakan kode unik tiap user\n# ISBN | International Standard Book Number merupakan kode unik masing masing buku\n# Book-Rating |Merupakan rating dari tiap buku\n\n# ### 3.1.3 User\n# \n# Berisikan data sebanyak 278858 baris dan 4 kolom yang terdiri dari: <br>\n# \n# Kolom  | Keterangan\n# :------------- | :-------------\n# Sumber  | https://www.kaggle.com/arashnic/book-recommendation-dataset?select=Users.csv\n# User-ID | Merupakan kode unik tiap user\n# Age | Merupakan umur tiap user\n# Location |Merupakan lokasi tiap user \n\n# ## 3.2 Cek Missing Values, tipe data & summary statistical descriptive\n\n# ### 3.2.1 Book\n\n# In[6]:\n\n\npd.DataFrame(df_book.isnull().sum(), columns=['missing_values'])\n\n\n# In[7]:\n\n\ndf_book.info()\n\n\n# In[8]:\n\n\ndf_book.loc[:,:'Publisher'].describe(include=object)\n\n\n# ### 3.2.2 Rating\n\n# In[9]:\n\n\npd.DataFrame(df_rating.isnull().sum(), columns=['missing_values'])\n\n\n# In[10]:\n\n\ndf_rating.info()\n\n\n# In[11]:\n\n\ndf_rating[['Book-Rating']].describe()\n\n\n# In[12]:\n\n\ndf_rating['Book-Rating'] = df_rating['Book-Rating'].astype(object)\n\n\n# In[13]:\n\n\ndf_rating.describe(include=[object])\n\n\n# In[14]:\n\n\ndf_rating.info()\n\n\n# ### 3.2.3 User\n\n# In[15]:\n\n\ndf_user.head()\n\n\n# In[16]:\n\n\ndf_user.Location.unique()\n\n\n# In[17]:\n\n\ndf_user.Location.str.split(',',expand=True).loc[:,:2][0].unique()\n\n\n# In[18]:\n\n\nlen(df_user.Location.str.split(',',expand=True).loc[:,:2][0].unique())\n\n\n# In[19]:\n\n\ndf_user.Location.str.split(',',expand=True).loc[:,:2][1].unique()\n\n\n# In[20]:\n\n\nlen(df_user.Location.str.split(',',expand=True).loc[:,:2][1].unique())\n\n\n# In[21]:\n\n\ndf_user['city'] = df_user.Location.str.split(',',expand=True)[0]\n# df_user['nation_state'] = df_user.Location.str.split(',',expand=True)[1]\ndf_user['country'] = df_user.Location.str.split(',',expand=True)[2]\ndf_user.head()\n\n\n# In[22]:\n\n\npd.DataFrame(df_user.isnull().sum(), columns=['missing_values'])\n\n\n# In[23]:\n\n\ndf_user.info()\n\n\n# In[24]:\n\n\npd.set_option('display.max_rows',105)\n\n\n# In[25]:\n\n\ndf_user.groupby('country')[['country']].count().head(10)\n\n\n# In[26]:\n\n\ndf_user.drop(columns=['country'], inplace=True)\n\n\n# In[27]:\n\n\ndf_user[['Age']].describe()\n\n\n# In[28]:\n\n\ndf_user.describe(include=object)\n\n\n# `Kesimpulan dari Tahapan ini :`\n# 1. Book\n#     - Buku dengan judul terbanyak adalah Selected Poems dengan jumlah 27 buah\n#     - Penulis terbanyak adalah Agatha Christie dengan total 632 karya\n#     - Buku terbitan tahun 2002 menjadi buku terbanyak\n#     - Lembaga penerbit yang paling banayk menerbitkan buku adalah Harlequin\n# 2. Rating\n#     - masih banyak buku yang belum dirating, yakni sebanyak 716109\n# 3. User\n#     - Banyak data umur yang kosong kemungkinan tidak akan digunakan\n#     - london menjadi kota user terbanyak sebanyak 139187 user\n\n# ## 3.3 Visualisasi Data\n\n# ### 3.3.1 Book\n\n# In[29]:\n\n\ncount_book = {key: len(df_book[key].unique()) for key in df_book.columns[1:5]}\n\n\n# In[30]:\n\n\nplt.figure(figsize=(15,9))\nax = sns.barplot(x=list(count_book.keys()), y=list(count_book.values()))\nfor p in ax.patches:\n        ax.annotate(format(p.get_height(), '.1f'), (p.get_x() + p.get_width() / 2., p.get_height()), ha = 'center', va = 'center', xytext = (0, 10), textcoords = 'offset points')\nax.set_title(\"Banyak Data Unik Tiap Kolom Dataset Book\")\nplt.show()\n\n\n# ### 3.3.2 Rating\n\n# In[31]:\n\n\ncount_rating = {key: len(df_rating[key].unique()) for key in df_rating.columns}\n\n\n# In[32]:\n\n\nplt.figure(figsize=(15,9))\nax = sns.barplot(x=list(count_rating.keys()), y=list(count_rating.values()))\nfor p in ax.patches:\n        ax.annotate(format(p.get_height(), '.1f'), (p.get_x() + p.get_width() / 2., p.get_height()), ha = 'center', va = 'center', xytext = (0, 10), textcoords = 'offset points')\nax.set_title(\"Banyak Data Unik Tiap Kolom Dataset Rating\")\nplt.show()\n\n\n# In[33]:\n\n\nplt.figure(figsize=(15,9))\nax = sns.countplot(data=df_rating, x='Book-Rating')\nfor p in ax.patches:\n        ax.annotate(format(p.get_height(), '.1f'), (p.get_x() + p.get_width() / 2., p.get_height()), ha = 'center', va = 'center', xytext = (0, 10), textcoords = 'offset points')\nax.set_title(\"Banyak Data Unik Kolom Rating\")\nplt.show()\n\n\n# ### 3.3.3 Users\n\n# In[34]:\n\n\ndf_user.head()\n\n\n# In[35]:\n\n\ncount_users = {key: len(df_user[key].unique()) for key in df_user.columns}\n\n\n# In[36]:\n\n\nplt.figure(figsize=(12,9))\nax = sns.barplot(x=list(count_users.keys()), y=list(count_users.values()))\nfor p in ax.patches:\n        ax.annotate(format(p.get_height(), '.1f'), (p.get_x() + p.get_width() / 2., p.get_height()), ha = 'center', va = 'center', xytext = (0, 10), textcoords = 'offset points')\nax.set_title(\"Banyak Data Unik Tiap Kolom Dataset User\")\nplt.show()\n\n\n# In[37]:\n\n\ncity_top10 = df_user.city.value_counts().head(10).reset_index()\ncity_top10.columns = ['city', 'count']\ncity_top10\n\n\n# In[38]:\n\n\nplt.figure(figsize=(12,9))\nax = sns.barplot(x=city_top10.city, y=city_top10['count'])\nfor p in ax.patches:\n        ax.annotate(format(p.get_height(), '.1f'), (p.get_x() + p.get_width() / 2., p.get_height()), ha = 'center', va = 'center', xytext = (0, 10), textcoords = 'offset points')\nax.set_title(\"Top 10 Kota Terbanyak\")\nplt.show()\n\n\n# # 4. Data Preparation & Data Preprocessing\n\n# ## 4.1 Memilih fitur untuk sistem rekomendasi\n\n# In[39]:\n\n\ndf_fix = df_book.iloc[:,0:4]\ndf_fix.head()\n\n\n# In[40]:\n\n\npd.DataFrame({\n    'missing_values':df_fix.isnull().sum(),\n    'presentase':df_fix.isnull().sum()/len(df_fix)\n})\n\n\n# ## 4.2 Hapus Missing Value dan data duplicate pada dataset fix\n\n# In[41]:\n\n\ndf_fix.dropna(inplace=True)\ndf_fix.drop_duplicates(inplace=True)\n\n\n# In[42]:\n\n\ndf_fix.shape\n\n\n# ## 4.3 Create Metadata\n\n# In[43]:\n\n\ndf_fix['Year-Of-Publication'] = df_fix['Year-Of-Publication'].astype('str')\n\n\n# In[44]:\n\n\ndf_fix['metadata'] = \"\"\nfor col in ['Book-Title', 'Book-Author', 'Year-Of-Publication']:\n    df_fix['metadata'] += df_fix[col]\n    df_fix['metadata'] += \" \"\n\n\n# In[45]:\n\n\ndf_fix.tail()\n\n\n# ## 4.4 Encoding dengan TF-IDF\n\n# In[46]:\n\n\nfrom sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n\n\n# In[47]:\n\n\nbow = CountVectorizer()\nbank = bow.fit_transform(df_fix.metadata)\n\n\n# In[48]:\n\n\ntfidf = TfidfVectorizer()\nbank2 = tfidf.fit_transform(df_fix.metadata)\n\n\n# # 5. Modeling\n\n# ## 5.1 Encoding metadata index\n\n# In[49]:\n\n\nindex = 0\ncontent = df_fix.loc[index, 'metadata']\ncontent\n\n\n# In[50]:\n\n\ncode1 = bow.transform([content])\ncode1\n\n\n# In[51]:\n\n\ncode2 = tfidf.transform([content])\n\n\n# ## 5.2 Document Search\n\n# In[52]:\n\n\nfrom sklearn.metrics.pairwise import cosine_distances\n\n\n# In[53]:\n\n\ndistance1 = cosine_distances(code1, bank)\ndistance1\n\n\n# In[54]:\n\n\nrec_idx = distance1.argsort()[0, 1:]\nrec_idx\n\n\n# In[55]:\n\n\ndf_fix.loc[rec_idx[:5], :]\n\n\n# In[56]:\n\n\ndistance2 = cosine_distances(code2, bank)\ndistance2\n\n\n# In[57]:\n\n\nrec_idx2 = distance2.argsort()[0, 1:]\nrec_idx2\n\n\n# In[58]:\n\n\ndf_fix.loc[rec_idx2[:10], :]\n\n\n# ## 5.3 Bungkus code agar rapih\n\n# In[59]:\n\n\nclass RecommendationSystems():\n    def __init__(self,data, metadata_col):\n        self.df = data\n        self.metadata = metadata_col\n        self.encoder = None\n        self.bank = None\n    \n    def fit(self, encoder='tfidf'):\n        if encoder not in ['bow', 'tfidf']:\n            print(\"hanya support BoW dan TF-IDF\")\n        else:\n            self.encoder = TfidfVectorizer()\n            if encoder=='bow':\n                self.encoder = CountVectorizer()\n            self.bank = self.encoder.fit_transform(self.df[self.metadata])\n    def recommender(self, index, topn=10):\n        content = self.df.loc[index, self.metadata]\n        code = self.encoder.transform([content])\n        distance = cosine_distances(code, self.bank)\n        rec_idx = distance.argsort()[0, 1:]\n        return self.df.loc[rec_idx[:topn], :]\n\n\n# In[60]:\n\n\nrecsys = RecommendationSystems(df_fix, 'metadata')\nrecsys.fit()\n\n\n# In[61]:\n\n\nrec = recsys.recommender(100)\nrec\n\n\n# In[62]:\n\n\ndf_fix.loc[100,:]\n\n\n# In[63]:\n\n\nrecsys2 = RecommendationSystems(df_fix, 'metadata')\nrecsys2.fit('bow')\n\n\n# In[64]:\n\n\nrec2 = recsys2.recommender(100)\nrec2\n\n\n# ## 5.4 Scoring\n\n# ## 5.4.1 Try\n\n# In[65]:\n\n\nfrom sklearn.metrics.pairwise import cosine_similarity\nimport numpy as np\n\n\n# In[66]:\n\n\nbook = pd.DataFrame(dict(df_fix.loc[100,:]), index=[0])\nbook\n\n\n# In[67]:\n\n\nrec2\n\n\n# In[68]:\n\n\nnp.mean(cosine_similarity(bow.transform(book.metadata.values), bow.transform(rec.metadata)))\n\n\n# In[69]:\n\n\nnp.mean(cosine_similarity(tfidf.transform(book.metadata.values), tfidf.transform(rec.metadata)))\n\n\n# ## 5.4.2 Bungkus kembali kedalam class\n\n# In[70]:\n\n\nclass RecommendationSystems():\n    def __init__(self,data, metadata_col):\n        self.df = data\n        self.metadata = metadata_col\n        self.encoder = None\n        self.bank = None\n        self.content = None\n        self.index = None\n        self.topn = None\n    \n    def fit(self, encoder='tfidf'):\n        if encoder not in ['bow', 'tfidf']:\n            print(\"hanya support BoW dan TF-IDF\")\n        else:\n            self.encoder = TfidfVectorizer()\n            if encoder=='bow':\n                self.encoder = CountVectorizer()\n            self.bank = self.encoder.fit_transform(self.df[self.metadata])\n    def recommender(self, index, topn=10, include_book_search=False):\n        self.index = index       \n        self.topn = topn\n        self.content = self.df.loc[index, self.metadata]\n        code = self.encoder.transform([self.content])\n        distance = cosine_distances(code, self.bank)\n        rec_idx = distance.argsort()[0, :]\n        if include_book_search:\n            topn+=1\n            return self.df.loc[rec_idx[:topn], :] \n        return self.df.loc[rec_idx[1:topn], :]\n\n    def score(self):\n        rec = self.recommender(index=self.index, topn=self.topn, include_book_search=True)\n        bank = self.encoder.transform(rec.metadata)\n        code = self.encoder.transform([self.content])\n        return np.mean(cosine_similarity(code, bank)[:,1:])\n\n\n# In[71]:\n\n\nrecsys3 = RecommendationSystems(df_fix, 'metadata')\nrecsys3.fit()\nrecsys3.recommender(index=100, include_book_search=True)\n\n\n# In[72]:\n\n\nrecsys3.score()\n\n\n# In[73]:\n\n\nimport time\n\n\n# In[74]:\n\n\nstart = time.time()\nrecsys4 = RecommendationSystems(df_fix, 'metadata')\nrecsys4.fit('bow')\nrecsys4.recommender(index=100)\nstop = time.time()\nprint(f\"Training time: {stop - start} s\")\nprint(\"Score : \",recsys4.score())\n\n\n# ## 5.4.3 Scoring Model dengan *Bag Of Word* top 5 rekomendasi\n\n# In[75]:\n\n\nrecsys = RecommendationSystems(data=df_fix, metadata_col='metadata')\nrecsys.fit(encoder='bow')\n\n\n# In[76]:\n\n\nrecsys.recommender(index=100, topn=5, include_book_search=True)\n\n\n# In[77]:\n\n\nrecsys.score()\n\n\n# In[78]:\n\n\nrecsys.recommender(index=1000, topn=5, include_book_search=True)\n\n\n# In[79]:\n\n\nrecsys.score()\n\n\n# ## 5.4.4 Scoring Model Tf-idf\n\n# In[80]:\n\n\nrecsys = RecommendationSystems(data=df_fix, metadata_col='metadata')\nrecsys.fit(encoder='tfidf')\n\n\n# In[81]:\n\n\nrecsys.recommender(index=100, topn=5, include_book_search=True)\n\n\n# In[82]:\n\n\nrecsys.score()\n\n\n# In[83]:\n\n\nrecsys.recommender(index=1000, topn=5, include_book_search=True)\n\n\n# In[84]:\n\n\nrecsys.score()\n\n\n# # 6 Evaluasi\n\n# ## 6.1 Generate data yang akan dijadikan sampel sebanyak 500 data\n\n# In[85]:\n\n\nnp.random.randint(0,10, 5)\n\n\n# In[86]:\n\n\nidx_sample_list = np.random.randint(0,len(df_fix), 500)\nidx_sample_list\n\n\n# In[87]:\n\n\nlen(idx_sample_list)\n\n\n# In[88]:\n\n\nidx_sample_list2 = [i for i in np.random.randint(0,len(df_fix), 500) if i not in idx_sample_list]\nlen(idx_sample_list2)\n\n\n# In[89]:\n\n\nfrom tqdm import tqdm\n\n\n# ## 6.2 Define Loop Function\n\n# In[90]:\n\n\ndef loop_rec(data, metadata_col='metadata', encoder='tfidf', sample_list=[0,2,10],topn=10, return_dict=False):\n    score_list = []\n    score_dict = {}\n    idx_done = []\n    recsys = RecommendationSystems(data, metadata_col)\n    recsys.fit(encoder)\n    for i in tqdm(sample_list):\n        while True:\n            idx = np.random.randint(low=0, high=len(data))\n            if idx not in idx_done:\n                idx_done.append(idx)\n                break\n        recsys.recommender(index=idx, topn=topn)\n        score = recsys.score()\n        score_list.append(score)\n        score_dict[idx] = score\n    if return_dict:\n        return score_dict, np.mean(score_list)\n    return np.mean(score_list)\n\n\n# ## 6.3 Model Bag-of-word \n\n# In[91]:\n\n\ndict_score_bow, score_bow = loop_rec(data=df_fix,\n                                     metadata_col='metadata',\n                                     encoder='bow',\n                                     topn=5,\n                                     sample_list=idx_sample_list,\n                                     return_dict=True)\n\n\n# In[92]:\n\n\nscore_bow\n\n\n# In[93]:\n\n\ndict_score_bow2, score_bow2 = loop_rec(data=df_fix,\n                                     metadata_col='metadata',\n                                     encoder='bow',\n                                     topn=5,\n                                     sample_list=idx_sample_list2,\n                                     return_dict=True)\n\n\n# In[94]:\n\n\nscore_bow2\n\n\n# ## 6.4 Model Tf-idf\n\n# In[95]:\n\n\ndict_score_tfidf, score_tfidf = loop_rec(data=df_fix,\n                                     metadata_col='metadata',\n                                     encoder='tfidf',\n                                     topn=5,\n                                     sample_list=idx_sample_list,\n                                     return_dict=True)\n\n\n# In[96]:\n\n\nscore_tfidf\n\n\n# In[97]:\n\n\ndict_score_tfidf2, score_tfidf2 = loop_rec(data=df_fix,\n                                     metadata_col='metadata',\n                                     encoder='tfidf',\n                                     topn=5,\n                                     sample_list=idx_sample_list2,\n                                     return_dict=True)\n\n\n# In[98]:\n\n\nscore_tfidf2\n\n\n# In[100]:\n\n\npd.DataFrame({\n    'Tf-Idf':[score_tfidf, score_tfidf2],\n    'BoW':[score_bow, score_bow2]\n})\n\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "06524eeb2113b8387d2c1927ba6741c286bc9ea1", "size": 17232, "ext": "py", "lang": "Python", "max_stars_repo_path": "Book Recommendation System/content_base_filtering.py", "max_stars_repo_name": "ahmadhabib5/Applied_Machine_Learning", "max_stars_repo_head_hexsha": "cb3e63bd90d6657e1a0664fa811eb4ecc9197117", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-11-14T11:39:13.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-14T11:39:18.000Z", "max_issues_repo_path": "Book Recommendation System/content_base_filtering.py", "max_issues_repo_name": "ahmadhabib5/Applied_Machine_Learning", "max_issues_repo_head_hexsha": "cb3e63bd90d6657e1a0664fa811eb4ecc9197117", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Book Recommendation System/content_base_filtering.py", "max_forks_repo_name": "ahmadhabib5/Applied_Machine_Learning", "max_forks_repo_head_hexsha": "cb3e63bd90d6657e1a0664fa811eb4ecc9197117", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-17T06:12:39.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-17T06:12:39.000Z", "avg_line_length": 18.7304347826, "max_line_length": 298, "alphanum_fraction": 0.6371866295, "include": true, "reason": "import numpy", "num_tokens": 4748, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3522017684487511, "lm_q2_score": 0.1847675061589216, "lm_q1q2_score": 0.0650754424210377}}
{"text": "r\"\"\"\nElements of posets, lattices, semilattices, etc.\n\"\"\"\n#*****************************************************************************\n#       Copyright (C) 2008 Peter Jipsen <jipsen@chapman.edu>,\n#                          Franco Saliola <saliola@gmail.com>\n#\n#  Distributed under the terms of the GNU General Public License (GPL)\n#\n#    This code is distributed in the hope that it will be useful,\n#    but WITHOUT ANY WARRANTY; without even the implied warranty of\n#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n#    General Public License for more details.\n#\n#  The full text of the GPL is available at:\n#\n#                  http://www.gnu.org/licenses/\n#*****************************************************************************\nfrom sage.structure.element import Element\nfrom sage.structure.element import have_same_parent\n\nclass PosetElement(Element):\n\n    def __init__(self, poset, element, vertex):\n        r\"\"\"\n        Establishes the parent-child relationship between ``poset``\n        and ``element``, where ``element`` is associated to the\n        vertex ``vertex`` of the Hasse diagram of the poset.\n\n        INPUT:\n\n        - ``poset`` - a poset object\n\n        - ``element`` - any object\n\n        - ``vertex`` - a vertex of the Hasse diagram of the poset\n\n        TESTS::\n\n            sage: from sage.combinat.posets.elements import PosetElement\n            sage: P = Poset([[1,2],[4],[3],[4],[]], facade = False)\n            sage: e = P(0)\n            sage: e.parent() is P\n            True\n            sage: TestSuite(e).run()\n        \"\"\"\n        Element.__init__(self, poset)\n        if isinstance(element, self.parent().element_class):\n            self.element = element.element\n        else:\n            self.element = element\n        self.vertex = vertex\n\n    def __hash__(self):\n        r\"\"\"\n        TESTS::\n\n            sage: P = Poset([[1,2],[4],[3],[4],[]], facade = False)\n            sage: e = P(0)\n            sage: hash(e)\n            0\n        \"\"\"\n        return hash(self.element)\n\n    def _repr_(self):\n        \"\"\"\n        TESTS::\n\n            sage: Poset([[1,2],[4],[3],[4],[]], facade = False)(0)._repr_()\n            '0'\n        \"\"\"\n        return \"%s\" %str(self.element)\n\n    def _latex_(self):\n        r\"\"\"\n        Return the latex code of the poset element.\n\n        EXAMPLES::\n\n            sage: m = matrix(2,[1,2,3,4])\n            sage: m.set_immutable()\n            sage: P = Poset(([m],[]), facade = False)\n            sage: [e] = P\n            sage: type(e)\n            <class 'sage.combinat.posets.elements.FinitePoset_with_category.element_class'>\n            sage: latex(e)                 #indirect doctest\n            \\left(\\begin{array}{rr}\n            1 & 2 \\\\\n            3 & 4\n            \\end{array}\\right)\n        \"\"\"\n        from sage.misc.latex import latex\n        return latex(self.element)\n\n    def __eq__(self,other):\n        \"\"\"\n        TESTS::\n\n            sage: P = Poset([[\"a\",\"b\"],[\"d\"],[\"c\"],[\"d\"],[]], facade = False)\n            sage: Q = Poset([[\"a\",\"b\"],[\"d\"],[\"c\"],[],[]], facade = False)\n            sage: P(0).__eq__(P(4))\n            False\n            sage: from sage.combinat.posets.elements import PosetElement\n            sage: PosetElement(P,0,\"c\") == PosetElement(P,0,\"c\")\n            True\n            sage: PosetElement(P,0,\"c\") == PosetElement(Q,0,\"c\")\n            False\n            sage: PosetElement(P,0,\"b\") == PosetElement(P,0,\"c\")\n            False\n\n        .. warning:: as an optimization, this only compares the parent\n           and vertex, using the invariant that, in a proper poset\n           element, ``self.element == other.element`` if and only\n           ``self.vertex == other.vertex``::\n\n            sage: PosetElement(P,1,\"c\") == PosetElement(P,0,\"c\")\n            True\n\n        Test that :trac:`12351` is fixed::\n\n            sage: P(0) == int(0)\n            False\n        \"\"\"\n        # This should instead exploit unique representation, using\n        # self is other, or best inherit __eq__ from there. But there\n        # are issues around pickling and rich comparison functions.\n        return have_same_parent(self, other) \\\n            and self.vertex == other.vertex\n\n\n    def __ne__(self,other):\n        r\"\"\"\n        TESTS::\n\n            sage: P = Poset([[1,2],[4],[3],[4],[]])\n            sage: P = Poset([[\"a\",\"b\"],[\"d\"],[\"c\"],[\"d\"],[]])\n            sage: P(0).__ne__(P(4))\n            True\n            sage: from sage.combinat.posets.elements import PosetElement\n            sage: PosetElement(P,0,\"c\") != PosetElement(P,0,\"c\")\n            False\n            sage: PosetElement(P,0,\"b\") != PosetElement(P,0,\"c\")\n            True\n\n        For this one, see comment in :meth:`__eq__`::\n\n            sage: PosetElement(P,1,\"c\") != PosetElement(P,0,\"c\")\n            False\n        \"\"\"\n        return not self == other\n\n    def _cmp(self,other):\n        \"\"\"\n        TESTS::\n\n            sage: P = Poset([[1,2],[4],[3],[4],[]], facade = False)\n            sage: P(0)._cmp(P(4))\n            -1\n            sage: P(4)._cmp(P(0))\n            1\n            sage: P(0)._cmp(P(0))\n            0\n            sage: P(1)._cmp(P(2))\n\n        \"\"\"\n        return self.parent().compare_elements(self,other)\n\n    def __cmp__(self, other):\n        r\"\"\"\n        A default comparison of ``self`` with ``other``.\n\n        .. note::\n\n           The rich comparison methods have been implemented for poset\n           elements, so when a user asks for ``x < y``, for example, rich\n           comparison is used (that is, ``x.__lt__(y)`` is returned). This\n           method is implemented because ``PosetElement`` inherits from\n           ``Element``, which requires ``__cmp__`` to enable sorting by the\n           ``cmp`` method.\n\n           If both ``self`` and ``other`` have the same parent poset,\n           then the comparison is done in the poset. If the elements\n           are incomparable in the poset, then 0 is returned. Note that,\n           in particular, ``cmp(a,b) == cmp(b,a)`` if ``a`` and ``b`` are\n           equal or incomparable in the poset.\n\n        TESTS::\n\n            sage: P = Poset([[1,2],[4],[3],[4],[]], facade = False)\n            sage: P(0).__cmp__(P(4))\n            -1\n            sage: P(4).__cmp__(P(0))\n            1\n            sage: P(0).__cmp__(P(0))\n            0\n            sage: P(1).__cmp__(P(2))\n            0\n            sage: cmp(P(0),P(4))\n            -1\n            sage: cmp(P(4),P(0))\n            1\n            sage: cmp(P(0),P(0))\n            0\n            sage: cmp(P(1),P(2))\n            0\n            sage: cmp(P(2),P(1))\n            0\n        \"\"\"\n        if isinstance(other, type(self)):\n            r = self.parent().compare_elements(self,other)\n            if r is None:\n                return 0\n            else:\n                return r\n        else:\n            return cmp(type(other), type(self))\n\n    def __lt__(self,other):\n        \"\"\"\n        TESTS\n\n        ::\n\n            sage: dag = DiGraph({0:[2,3], 1:[3,4], 2:[5], 3:[5], 4:[5]})\n            sage: P = Poset(dag, facade = False)\n            sage: P(0) < P(1)\n            False\n            sage: P(4) < P(1)\n            False\n            sage: P(0) < P(0)\n            False\n        \"\"\"\n        return self._cmp(other) == -1 or False\n\n    def __le__(self,other):\n        \"\"\"\n        TESTS\n\n        ::\n\n            sage: dag = DiGraph({0:[2,3], 1:[3,4], 2:[5], 3:[5], 4:[5]})\n            sage: P = Poset(dag, facade = False)\n            sage: P(1) <= P(0)\n            False\n            sage: P(0) <= P(1)\n            False\n            sage: P(0) <= P(3)\n            True\n            sage: P(0) <= P(0)\n            True\n        \"\"\"\n        return self == other or self._cmp(other) == -1 or False\n\n    def __gt__(self,other):\n        \"\"\"\n        TESTS\n\n        ::\n\n            sage: dag = DiGraph({0:[2,3], 1:[3,4], 2:[5], 3:[5], 4:[5]})\n            sage: P = Poset(dag)\n            sage: P(0).__gt__(P(5))\n            False\n            sage: P(5).__gt__(P(0))\n            True\n            sage: P(0).__gt__(P(0))\n            False\n        \"\"\"\n        return self._cmp(other) == 1 or False\n\n    def __ge__(self,other):\n        \"\"\"\n        TESTS\n\n        ::\n\n            sage: dag = DiGraph({0:[2,3], 1:[3,4], 2:[5], 3:[5], 4:[5]})\n            sage: P = Poset(dag)\n            sage: P(0).__ge__(P(5))\n            False\n            sage: P(5).__ge__(P(0))\n            True\n            sage: P(0).__ge__(P(0))\n            True\n        \"\"\"\n        return self == other or self._cmp(other) == 1 or False\n\nclass MeetSemilatticeElement(PosetElement):\n    def __mul__(self,other):\n        r\"\"\"\n        Return the meet of ``self`` and ``other`` in the lattice.\n\n        EXAMPLES::\n\n            sage: D = Posets.DiamondPoset(5,facade=False)\n            sage: D(1) * D(2)\n            0\n            sage: D(1) * D(1)\n            1\n            sage: D(1) * D(0)\n            0\n            sage: D(1) * D(4)\n            1\n        \"\"\"\n        return self.parent().meet(self,other)\n\nclass JoinSemilatticeElement(PosetElement):\n    def __add__(self,other):\n        r\"\"\"\n        Return the join of ``self`` and ``other`` in the lattice.\n\n        EXAMPLES::\n\n            sage: D = Posets.DiamondPoset(5,facade=False)\n            sage: D(1) + D(2)\n            4\n            sage: D(1) + D(1)\n            1\n            sage: D(1) + D(4)\n            4\n            sage: D(1) + D(0)\n            1\n        \"\"\"\n        return self.parent().join(self,other)\n\nclass LatticePosetElement(MeetSemilatticeElement,JoinSemilatticeElement):\n    pass\n", "meta": {"hexsha": "9075256de8b2398fa94b175f02b06a613a37da0d", "size": 9542, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/combinat/posets/elements.py", "max_stars_repo_name": "fredstro/sage", "max_stars_repo_head_hexsha": "c936d2cda81ec7ec3552a3bdb29c994b40d1bb24", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-06-30T01:37:35.000Z", "max_stars_repo_stars_event_max_datetime": "2018-06-30T01:37:39.000Z", "max_issues_repo_path": "src/sage/combinat/posets/elements.py", "max_issues_repo_name": "boothby/sage", "max_issues_repo_head_hexsha": "1b1e6f608d1ef8ee664bb19e991efbbc68cbd51f", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/combinat/posets/elements.py", "max_forks_repo_name": "boothby/sage", "max_forks_repo_head_hexsha": "1b1e6f608d1ef8ee664bb19e991efbbc68cbd51f", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.0914634146, "max_line_length": 91, "alphanum_fraction": 0.4652064557, "include": true, "reason": "from sage", "num_tokens": 2572, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4111108836623764, "lm_q2_score": 0.1581743467959293, "lm_q1q2_score": 0.06502719548399366}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Classifying Pulsars from the High Time Resolution Universe Survey (HTRU2) - Exploratory Data Analysis\n\n# ## Overview & Citation\n\n# The purpose of this project is to analyze telescope data to correctly separate actual pulsar data from radio frequency noise. The dataset was retrieved from the UC Irvine Machine Learning Repository at the following link: <https://archive.ics.uci.edu/ml/datasets/HTRU2#>\n# \n# The data comes from the High Time Resolution Universe Survey (South), known as HTRU2. The dataset was donated to the UCI Repository by Dr. Robert Lyon of The University of Manchester, United Kingdom. The two papers requested for citation in the description are listed below:\n# * R. J. Lyon, B. W. Stappers, S. Cooper, J. M. Brooke, J. D. Knowles, Fifty Years of Pulsar Candidate Selection: From simple filters to a new principled real-time classification approach, Monthly Notices of the Royal Astronomical Society 459 (1), 1104-1123, DOI: 10.1093/mnras/stw656\n# * R. J. Lyon, HTRU2, DOI: 10.6084/m9.figshare.3080389.v1.\n# \n# Below is an edited description of the dataset, taken from the website. The citation numbers refer to the publications listed on the website:\n# \n# *HTRU2 is a data set which describes a sample of pulsar candidates collected during the High Time Resolution Universe Survey (South) [1]. Pulsars are a rare type of Neutron star that produce radio emission detectable here on Earth. They are of considerable scientific interest as probes of space-time, the inter-stellar medium, and states of matter (see [2] for more uses).* \n# \n# *As pulsars rotate, their emission beam sweeps across the sky, and when this crosses our line of sight, produces a detectable pattern of broadband radio emission. As pulsars\n# rotate rapidly, this pattern repeats periodically. Thus pulsar search involves looking for periodic radio signals with large radio telescopes. Each pulsar produces a slightly different emission pattern, which varies slightly with each rotation (see [2] for an introduction to pulsar astrophysics to find out why). Thus a potential signal detection known as a 'candidate', is averaged over many rotations of the pulsar, as determined by the length of an observation. In the absence of additional info, each candidate could potentially describe a real pulsar. However in practice almost all detections are caused by radio frequency interference (RFI) and noise, making legitimate signals hard to find.*\n# \n# *Machine learning tools are now being used to automatically label pulsar candidates to facilitate rapid analysis. Classification systems in particular are being widely adopted,\n# (see [4,5,6,7,8,9]) which treat the candidate data sets as binary classification problems. Here the legitimate pulsar examples are a minority positive class, and spurious examples the majority negative class. At present multi-class labels are unavailable, given the costs associated with data annotation. The data set shared here contains 16,259 spurious examples caused by RFI/noise, and 1,639 real pulsar examples. These examples have all been checked by human annotators.*\n\n# ## Feature Names\n\n# The dataset was downloaded from the UC Irvine Repository as a CSV file. Column names were not provided in the original dataset. The features are listed below according to the feature names listed on the website, with the annotated column names used in this project listed in parentheses:\n# \n# 1. Mean of the integrated profile. (IP_Mean)\n# 2. Standard deviation of the integrated profile. (IP_StdDev)\n# 3. Excess kurtosis of the integrated profile. (IP_Kurtosis)\n# 4. Skewness of the integrated profile. (IP_Skewness)\n# 5. Mean of the DM-SNR curve. (DM_Mean)\n# 6. Standard deviation of the DM-SNR curve. (DM_StdDev)\n# 7. Excess kurtosis of the DM-SNR curve. (DM_Kurtosis)\n# 8. Skewness of the DM-SNR curve. (DM_Skewness)\n# 9. Class (Class)\n# \n# The XLSX and CSV files with the added column names are provided in the GitHub repository. We will import and explore the data in the following sections.\n\n# ## Exploratory Data Analysis\n\n# ### Import the Relevant Libraries\n\n# In[1]:\n\n\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nget_ipython().run_line_magic('matplotlib', 'inline')\nsns.set()\n\n\n# ### Import & Check the Data\n\n# In[3]:\n\n\ndf = pd.read_csv('2020_1125_Pulsar_Data.csv')\npulsar_data = df.copy()\n\n\n# In[4]:\n\n\npulsar_data.head()\n\n\n# In[9]:\n\n\n# Showing only data for input variables, since the statistics for binary variables in Class are meaningless\npulsar_data.drop('Class',axis=1,inplace=False).describe()\n\n\n# ### Data Visualization\n\n# The visualization below shows paired plots for every input and outut variable.\n\n# In[10]:\n\n\nsns.pairplot(pulsar_data)\n\n\n# ## Modeling Recommendations\n\n# This dataset poses a binary classification problem. All input values are numerical, and the output variable is categorical. Since there are no null values in the dataset, no additional preprocessing is requred prior to modeling. The following classification models should be explored and compared for performance:\n# * Multiple Logistic Regression\n# * Decision Tree Classification\n# * Random Forest Classification\n# * Support Vector Machines (SVM)\n# * Deep Artificial Neural Networks (DNN)\n", "meta": {"hexsha": "372f51c33dcbc88e8a90425ceed2f6bd7524bfb4", "size": 5295, "ext": "py", "lang": "Python", "max_stars_repo_path": "02_Python_Code/01_Exploratory_Data_Analysis/2020_1127_Exploratory_Data_Analysis.py", "max_stars_repo_name": "ericdhitchens/Classifying_Pulsars_from_HTRU2", "max_stars_repo_head_hexsha": "6010031cf7a3ff92d4d1b12914012d6bb809debc", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "02_Python_Code/01_Exploratory_Data_Analysis/2020_1127_Exploratory_Data_Analysis.py", "max_issues_repo_name": "ericdhitchens/Classifying_Pulsars_from_HTRU2", "max_issues_repo_head_hexsha": "6010031cf7a3ff92d4d1b12914012d6bb809debc", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "02_Python_Code/01_Exploratory_Data_Analysis/2020_1127_Exploratory_Data_Analysis.py", "max_forks_repo_name": "ericdhitchens/Classifying_Pulsars_from_HTRU2", "max_forks_repo_head_hexsha": "6010031cf7a3ff92d4d1b12914012d6bb809debc", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 55.7368421053, "max_line_length": 702, "alphanum_fraction": 0.7779036827, "include": true, "reason": "import numpy", "num_tokens": 1235, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46879062662624377, "lm_q2_score": 0.13846178345871912, "lm_q1q2_score": 0.06490958623140021}}
{"text": "\n# coding: utf-8\n\n# # Analisi del problema di Quora\n# ---\n# \n# Il problema è proposto da http://www.quora.com. Il sito propone un sistema per condividere le proprie conoscenze in vari ambiti e per espandere queste stesse conoscenze. Questo grazie ad un sistema di semplici domande e risposte, che sono però organizzate in vari topic (interessi) che le persone possono seguire per personalizzare la loro esperienza. E’ presente un profilo personale che mostra domande e risposte e le conoscenze principali di ogni persona.\n# Il problema posto dall’azienda è il riconoscimento di domande che hanno lo stesso significato: sono molte infatti le domande che vengono ripetute (per pigrizia degli utenti o anche a causa della ricerca). Diventerebbe quindi importante ottimizzare il numero di domande unendo quelle uguali (con stesso scopo), ma anche (e soprattutto) unire le risposte, per rendere più completa possibile l’esperienza dell’utente riguardo lo specifico argomento della domanda.\n# Attualmente il sistema utilizza un modello RandomForest per identificare le domande uguali: la sfida lanciata è quella di trovare degli algoritmi migliori di rilevamento usando tecniche avanzate di Machine Learning e di Natural Language Processing.\n# \n# Il problema si presenta come una classificazione binaria con l'uso di addestramento supervisionato\n# \n# # Analisi  Training Set\n# ---\n# \n# Abbiamo iniziato ad analizzare il dataset partendo dal Training Set (`train.csv`).\n# L'header indica la denominazione delle 5 features e del label:\n# 1. `id` = id della coppia di domande\n# 2. `qid1` = id della prima domanda\n# 3. `qid2` = id della seconda domanda\n# 4. `question1` = testo della prima domanda\n# 5. `question2` = testo della seconda domanda\n# 6. `is_duplicate` = indica se le due domande sono uguali (è il label)\n\n# In[1]:\n\n\nget_ipython().run_cell_magic('time', '', \"\\nimport pandas as pd\\nimport numpy as np\\nimport time\\n\\n#Read dataset\\ntrain = pd.read_csv('/usr/local/share/kaggle/Quora Question Pairs/uncompressed/train.csv')\\n\\n#Print dataframe columns types infos\\nprint(train.dtypes)\\n\\n#Print some examples\\ntrain.head()\\nprint(len(train))\")\n\n\n# # Elaborazione dei dati\n# ---\n# \n# Inizialmente, seguendo i suggerimenti trovati in alcuni notebook presenti su kaggle, si era deciso di ripulire il dataset, eliminando tutto ciò che non fosse lettere o numeri. \n# Questa decisione si è rivelata poi controproducente in quanto l'algoritmo risulta meno performante su di un dataset \"pulito\".\n# \n# Si noti la differenza tra una frase \"sporca\" e una \"pulita\"\n\n# ### FASE 0A: Creazione dizionari\n# \n# Inizialmente è utile costruire delle strutture dati che poi saranno impiegate nel corso dell'elaborazione dei dati; anche se esse vengono utilizzate in fasi diverse dell'elaborazione risulta utile crearle tutte insime in un unica operazione.\n# Le strutture dati sono le seguenti\n# \n# * `dictionary`: Dizionario che associa a ciascuna parola un id intero\n# * `f_list`: lista che associa a ciascuna parola la propria frequenza, nello specifico contiene coppie (`id_parola`, `frequenza_parola`); la lista è ordinata in ordine decrescente di frequenza\n# * `n_data`: dataset formato da due colonne contenente le coppie di domande, dove ciascuna domanda è rappresentata da un array di `id_parola`\n# * `id_train`: `n_data` con l'aggiunta di una prima colonna contenente l'id della coppia di domande \n# \n\n# In[2]:\n\n\nget_ipython().run_cell_magic('time', '', \"\\ndef build_dictionary(data):\\n    #Initialization\\n    dictionary = {} #dizionario: stringa -> id\\n    c = 0\\n    frequency_list = [] #lista frequenze: list[id] = (id_parola, frequenza_parola)\\n    converted_data = [] #dataset che contiene numeri al posto delle parole \\n    #Takes every word in every couple and creates a dictionary\\n    for col in ['question1', 'question2']:\\n        new_col = []\\n        for sentence in data[col]:\\n            sentence_converted = []\\n            sentence = str(sentence).split(' ')\\n            for p in sentence:\\n                #Checks if word is already in dictionary\\n                if str(p) not in dictionary.keys():\\n                    #Checks length of word and if it's a space, then add\\n                    if not (len(str(p)) == 1 and ord(str(p)) == 32):\\n                        dictionary[str(p)] = c\\n                        frequency_list.append((c,1))\\n                        sentence_converted.append(c)\\n                        c = c+1\\n\\n                else:\\n                    c_old = dictionary[str(p)]\\n                    (n, freq) = frequency_list[c_old]\\n                    frequency_list[c_old] = (n, freq+1)\\n                    sentence_converted.append(c_old)\\n\\n            new_col.append(sentence_converted)\\n\\n        converted_data.append(new_col)            \\n\\n    sorted_frequency_list = sorted(frequency_list, key=lambda pair: pair[1], reverse=True)                \\n\\n    return dictionary, sorted_frequency_list, converted_data\\n\\ndictionary, f_list, n_data = build_dictionary(train)\\n\\nid_train = pd.DataFrame({\\n        'id': train['id'],\\n        'question1': n_data[0],\\n        'question2': n_data[1]\\n        })\")\n\n\n# ### Fase 0B: Inizializzazione rete di test\n# ---\n# \n# La rete prescelta per la soluzione di questo problema è `MLPClassifier` presente all'interno del package `sklearn`.\n# Come funzione di attivazione è stata scelta `logistic` in quanto la probabilità che le due domande siano un duplicato è rappresentata da un numero reale compreso tra 0 e 1 (come da istruzioni presenti sul sito)\n# Come algoritmo solver è stato scelto `adam` perchè, dopo aver effettuato dei test di confronto con gli altri algoritmi, è risultato essere quello che dava il risultato migliore\n# Come metrica di valutazione è stata scelta la funzione `LogLoss` in quanto è la stessa utilizzata da Kaggle\n# \n# In questa fase seleziono anche il numero di elementi da usare come insieme di train e quanti invece come insieme di test\n\n# In[3]:\n\n\nfrom sklearn.neural_network import MLPClassifier\nfrom sklearn.metrics import log_loss\n\nfrom keras.models import Sequential\nfrom keras.layers import Dropout, Dense, BatchNormalization\nfrom keras.losses import binary_crossentropy\nimport keras.utils as kUtils\n\n#labels\nduplicate = train['is_duplicate']\n\n#initialize algorithm\nalg = MLPClassifier(solver='adam', activation='logistic')\n\n# split dataset train/test\nsplit = np.random.rand(len(train)) < 0.8\n\n#funzione di test\ndef test(features, k=0):\n    \n    features_train = features[split]\n    features_test = features[~split]\n\n    labels_train = duplicate[split]\n    labels_test = duplicate[~split]\n\n    alg.fit(features_train, labels_train)\n    predict = alg.predict_proba(features_test)\n    logLoss = log_loss(labels_test, predict)\n\n    print('Sklearn Log Loss: {}'.format(logLoss))\n    \n    plot(predict[:,1], labels_test)\n    \n    ###KERAS NETWORK###\n    features_train = np.asmatrix(features_train)\n    features_test = np.asmatrix(features_test)\n    \n    labels_train = np.asmatrix(labels_train)\n    labels_test = np.asmatrix(labels_test)\n    \n    labels_train = kUtils.to_categorical(labels_train, 2)\n    labels_test = kUtils.to_categorical(labels_test, 2)\n    \n    model = Sequential()\n    model.add(Dense(200, activation='relu', input_dim = features_train.shape[1]))\n    model.add(Dropout(0.1))\n    model.add(BatchNormalization())\n    model.add(Dense(100, activation='relu'))\n    model.add(Dropout(0.1))\n    model.add(BatchNormalization())\n    model.add(Dense(2, activation='sigmoid'))\n    \n    model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n    \n    model.fit(features_train, labels_train,\n          batch_size=128,\n          epochs=20,\n          verbose=0,\n          validation_data=(features_test, labels_test))\n    \n    score = model.evaluate(features_test, labels_test, verbose=0)\n    keras_predict = model.predict_proba(features_test)\n\n    print('Keras Log loss: {}'.format(score[0]))\n    #plot(keras_predict[:,1], labels_test)\n    \n    ####################\n    \n    if (k == 1):\n        return predict[:,1]\n    \n    \n\nimport matplotlib.pyplot as plt    \n\n#funzione per mostrare la distribuzione delle predizioni rispetto alle label di test\ndef plot(p, labels_test):\n\n    t = []\n    f = []\n\n    for p, l in zip(p, labels_test):\n        if l == True:\n            t.append(p)\n        else:\n            f.append(p)\n        \n    plt.hist(f, bins=20, normed=True, label='Not Duplicate')\n    plt.hist(t, bins=20, normed=True, alpha=0.7, label='Duplicate')\n    plt.show()\n\n\n# ### FASE 0C: Multithreading\n# ---\n# \n# Scrivo una funzione che suddivida il lavoro su 4 core in modo da velocizzare l'esecuzione dell'algoritmo\n\n# In[4]:\n\n\nfrom threading import Thread\nimport numpy as np\n\ndef split_work(fun, train):    \n    dataframes = np.array_split(train, 4)\n\n    threads = []\n    results = {}\n    i = 0\n    \n    for data in dataframes:\n        t = Thread(target=fun, args=(data, results, i))\n        threads.append(t)\n        t.start()\n        i = i+1\n\n    for t in threads:\n        t.join()\n\n    features = []    \n    for key in sorted(results):\n        features.extend(results[key])\n    \n    return features\n\n\n# ### FASE 0D: Salvataggio e caricamento delle strutture dati\n# ---\n\n# In[5]:\n\n\ndef save(s, o):\n    obj = np.asarray(o)\n    np.save(s, obj)\n        \ndef load(s):\n    return np.load(s)\n\ndef compute(fun, data, file):\n    if not os.path.exists(file):\n        res = split_work(fun, data)\n        save(file, res)\n    else:\n        res = load(file)\n    \n    return res\n\n\n# ### FASE 1: Estrazione Features di base\n# ---\n# \n# Come prima cosa risulta utile estrarre le feature più semplici che possono caratterizzare una frase:\n# \n# * `q1_words`: numero di parole contenute nella prima domanda\n# * `q1_letters`: numero di caratteri contenuti nella prima domanda\n# * `q2_words`: numero di parole contenute nella seconda domanda\n# * `q2_letters`: numero di lettere contenute nella seconda domanda\n# \n# Infatti risulta piuttosto intuitivo che frasi di simile lunghezza hanno più probabilità di avere lo stesso significato\n\n# In[6]:\n\n\nget_ipython().run_cell_magic('time', '', \"import os\\n\\ndef base_extraction(data):\\n\\n    if not os.path.exists('base_features.csv'):\\n        #Count number of words and letters for each 'question1'\\n        q1_words = data['question1'].apply(lambda x: len(str(x).split(' ')))\\n        q1_letters = data['question1'].apply(lambda x: len(str(x)))\\n\\n        #Count number of words and letters for each 'question2'\\n        q2_words = data['question2'].apply(lambda x: len(str(x).split(' ')))\\n        q2_letters = data['question2'].apply(lambda x: len(str(x)))\\n\\n        features = pd.DataFrame({\\n                    'q1_words': q1_words,\\n                    'q1_letters': q1_letters,\\n                    'q2_words': q2_words,\\n                    'q2_letters': q2_letters,\\n                    })\\n        \\n        features.to_csv('base_features.csv', index=False, header=list(features))\\n    else:\\n        features = pd.read_csv('base_features.csv')\\n    \\n    return features\\n\\nfeatures = base_extraction(train)\\n\\n#TEST\\n\\n#test(features)\")\n\n\n# ### Fase 2: LCS\n# ---\n# \n# Dovendo stabilire la similarità tra due frasi un buon indicatore può essere la presenza di sottosequenze comuni, ho quindi deciso di prendere come parametro la lunghezza della più lunga sottostringa comune tra le due domande.\n\n# In[7]:\n\n\nget_ipython().run_cell_magic('time', '', \"\\ndef LCSLength(data, results, k):\\n    res =[]\\n    \\n    for row in data.itertuples():\\n        X = getattr(row, 'question1')\\n        Y = getattr(row, 'question2')\\n        m = len(X)\\n        n = len(Y)\\n        C = np.zeros((m,n), dtype=np.int8);\\n        for i in range(m):\\n            for j in range(n):\\n                if X[i] == Y[j]:\\n                    C[i,j] = C[i-1,j-1] + 1\\n                else:\\n                    C[i,j] = max(C[i,j-1], C[i-1,j])    \\n        res.append(C[m-1,n-1])\\n    results[k] = res\\n\\nLCSs = compute(LCSLength, id_train, 'LCS.npy')\\nfeatures = features.assign(**{'LCS' : LCSs})\\n\\n#TEST\\n\\n#test(features)\")\n\n\n# ### Fase 3: Word Similar Share\n# ---\n# \n# Appoggiandomi alla libreria `Spacy`, libreria specifica per il Natural Language Processing, ho calcolato un indice di similarità tra le due domande come somma degli indici di similarità tra ciascuna coppia di parole (`w1`,`w2`) dove `w1` appartiene alla prima domanda e `w2` alla seconda\n# \n# Inizialmente avevo normalizzato l'indice rispetto alla lunghezza delle due domande ma la predizione risultava più precisa senza normalizzazione\n\n# In[8]:\n\n\nimport spacy\nnlp = spacy.load('en_core_web_md')\n\n\n# In[9]:\n\n\ndef word_similar_share(data, results, i):\n    res = []\n    for row in data.itertuples():   \n        q1 = getattr(row, 'question1')\n        q2 = getattr(row, 'question2')\n    \n        q1words = nlp(str(q1))\n        q2words = nlp(str(q2))\n\n        jac = 0\n\n        for w1 in q1words:\n            s_w1 = str(w1)\n            if not (len(s_w1) == 1 and ord(s_w1) == 32):\n                for w2 in q2words:\n                    s_w2 = str(w2)\n                    if not (len(s_w2) == 1 and ord(s_w2) == 32):\n                        jac = jac + w1.similarity(w2)\n        \n        res.append(jac)\n    results[i] = res\n############################################\n\n#word_match = split_work(word_similar_share, train)    \n#features_tmp = features.assign(**{'Word_Match' : word_match})\n\n#TEST\n\n#test(features_tmp)\n\n\n# ### Fase 4: Common/Rare Words\n# ---\n# \n# In miglioramento dell'algoritmo visto alla fase 3 è l'introduzione del concetto di parola comune e parola rara\n# Una parola è considerata rara se la sua frequenza è bassa, e similmente è considerata comune se la sua frequenza è alta\n# \n# Si ottengono quindi due algoritmi distinti, entrambi ignorano le parole comuni\n# * `word_match_rare_function`: prendendo in considerazione le parole rare si ottiene un indice di similarità che viene incrementato di 1 per ogni parola rara che le due domande hanno in comune e decrementato di 1 per ogni parola rara che compare in una sola delle due domande\n# * `word_similar_share_cr`: come il `word_similar_share` visto al punto 3\n# \n# Anche in questo caso normalizzare gli indici ne riduce la capacità predittiva\n\n# In[10]:\n\n\ndef word_match_rare_function(data, results, i):\n    res = []\n    for row in data.itertuples():   \n        q1words = getattr(row, 'question1')\n        q2words = getattr(row, 'question2')\n\n        rare_jac = 0\n        #n_rare = 0\n        q1_rares = set()\n        q2_rares = set()\n\n        for w1 in q1words:\n            if w1 in rare_words:\n                q1_rares.add(w1)\n\n        for w2 in q2words:\n            if w2 in rare_words:\n                q2_rares.add(w2)\n\n        for w1r in q1_rares:\n            if w1r in q2_rares:\n                rare_jac = rare_jac + 1\n            else:\n                rare_jac = rare_jac - 1\n\n        for w2r in q2_rares:\n            if not w2r in q1_rares:\n                rare_jac = rare_jac - 1\n        '''                \n        try:\n            rare_jac = rare_jac/n_rare\n        except:\n            rare_jac = 0                            \n        '''\n        res.append(rare_jac)\n    results[i] = res\n\ndef word_similar_share_cr(data, results, i):\n    res = []\n    for row in data.itertuples():   \n        q1 = getattr(row, 'question1')\n        q2 = getattr(row, 'question2')\n    \n        q1words = nlp(str(q1))\n        q2words = nlp(str(q2))\n\n        jac = 0\n\n        for w1 in q1words:\n            s_w1 = str(w1)\n            if not (len(s_w1) == 1 and ord(s_w1) == 32 and s_w1 not in common_words):\n                for w2 in q2words:\n                    s_w2 = str(w2)\n                    if not (len(s_w2) == 1 and ord(s_w2) == 32 and s_w2 not in common_words):\n                        jac = jac + w1.similarity(w2)\n                try:\n                    jac = jac/(len(q1words)+len(q2words))\n                except:\n                    jac = 0                \n        res.append(jac)\n    results[i] = res\n\ncommon_words = set()\nrare_words = set()\n\n#build rare words set\nfor (p,f) in f_list:\n    if f<=20:\n        rare_words.add(p)\n\n#Build common words set\nfor (p,f) in f_list[:10]:\n    common_words.add(p)\n\n#Find similarity with Jaccard for each question pair\n#word_match_cr = split_work(word_similar_share_cr, train)\n#word_match_rare = split_work(word_match_rare_function, id_train)\n\n#features_tmp = features.assign(**{'Word_Match_cr' : word_match_cr})\n#features_tmp = features.assign(**{'Word_Match_rare' : word_match_rare})\n\n#TEST\n\n#test(features_tmp)\n\n\n# ### Fase 4B: vari valori per Common e Rare\n# ---\n# \n# I valori di frequenza per le parole comuni e rare al punto 4 erano stati scelti arbitrariamente, quindi in questa fase si testeranno vari valori per tali frequenze per determinare le migliori\n\n# In[11]:\n\n\n# start = time.time()\n\n# for F in range(20, 110, 10):\n#     for n in range(4, 11):\n#         data_tmp = features.copy()\n#         C = pow(2,n)\n\n#         common_words = set()\n#         rare_words = set()\n\n#         #build rare words list\n#         for (p,f) in f_list:\n#             if f<=F:\n#                 rare_words.add(p)\n\n#         #Build common words list\n#         for (p,f) in f_list[:C]:\n#             common_words.add(p)\n\n#         #Find similarity with Jaccard for each question pair\n#         word_match_cr = train.apply(word_similar_share_cr, axis=1, raw=True)\n#         word_match_rare = id_train.apply(word_match_rare_function, axis=1, raw=True)\n\n#         data_tmp = data_tmp.assign(**{'Word_Match_cr' : word_match_cr})\n#         data_tmp = data_tmp.assign(**{'Word_Match_rare' : word_match_rare})\n\n#         #TEST\n\n#         features_train = features_tmp[split]\n#         features_test = features_tmp[~split]\n\n#         labels_train = duplicate[split]\n#         labels_test = duplicate[~split]\n\n#         alg.fit(features_train, labels_train)\n#         predict = alg.predict_proba(features_test)\n#         logLoss = log_loss(labels_test, predict)\n\n#         results = []\n#         results.append((C,F,logLoss))\n#         print(\"Log loss C: {}, F: {} = {}\".format(C,F,logLoss))\n\n# sorted_results = sorted(results, key=lambda pair: pair[2])\n# print(sorted_results[:5])\n# end = time.time()\n# print('time: {}'.format(end - start))\n\n\n# ### Fase 4C: deduzioni\n# ---\n# \n# Dall'esecuzione della fase 5 si deduce che i parametri che danno il risultato migliore sono `C = 64 ` e `F = 50`. Non è detto che si rivelino buoni parametri anche per il set di test ma dato che comunque l'algoritmo basato sulle parole rare si ha dimostrato di dare buoni risultati terrò questi parametri validi anche per il caso di test.\n# In ogni caso il valore dei parametri incide poco sul risultato finale, in quanto il valore migliore risulta essere `0.4996397287043904` mentre il peggiore è `0.5068634596789862` per una differenza di `0.00722373097`\n\n# In[12]:\n\n\nget_ipython().run_cell_magic('time', '', \"\\nF = 50\\nC = 64\\n\\ndef word_match_rare_function(data, results, i):\\n    res = []\\n    for row in data.itertuples():   \\n        q1words = getattr(row, 'question1')\\n        q2words = getattr(row, 'question2')\\n\\n        rare_jac = 0\\n        #n_rare = 0\\n        q1_rares = set()\\n        q2_rares = set()\\n\\n        for w1 in q1words:\\n            if w1 in rare_words:\\n                q1_rares.add(w1)\\n\\n        for w2 in q2words:\\n            if w2 in rare_words:\\n                q2_rares.add(w2)\\n\\n        for w1r in q1_rares:\\n            if w1r in q2_rares:\\n                rare_jac = rare_jac + 1\\n            else:\\n                rare_jac = rare_jac - 1\\n\\n        for w2r in q2_rares:\\n            if not w2r in q1_rares:\\n                rare_jac = rare_jac - 1\\n        '''                \\n        try:\\n            rare_jac = rare_jac/n_rare\\n        except:\\n            rare_jac = 0                            \\n        '''\\n        res.append(rare_jac)\\n    results[i] = res\\n\\ndef word_similar_share_cr(data, results, i):\\n    res = []\\n    for row in data.itertuples():   \\n        q1 = getattr(row, 'question1')\\n        q2 = getattr(row, 'question2')\\n    \\n        q1words = nlp(str(q1))\\n        q2words = nlp(str(q2))\\n\\n        jac = 0\\n\\n        for w1 in q1words:\\n            s_w1 = str(w1)\\n            if not (len(s_w1) == 1 and ord(s_w1) == 32 and s_w1 not in common_words):\\n                for w2 in q2words:\\n                    s_w2 = str(w2)\\n                    if not (len(s_w2) == 1 and ord(s_w2) == 32 and s_w2 not in common_words):\\n                        jac = jac + w1.similarity(w2)\\n                '''\\n                try:\\n                    jac = jac/(len(q1words)+len(q2words))\\n                except:\\n                    jac = 0\\n                '''    \\n        res.append(jac)\\n    results[i] = res\\n\\ncommon_words = set()\\nrare_words = set()\\n\\n#build rare words set\\nfor (p,f) in f_list:\\n    if f<=F:\\n        rare_words.add(p)\\n\\n#Build common words set\\nfor (p,f) in f_list[:C]:\\n    common_words.add(p)\\n\\n#Find similarity with Jaccard for each question pair\\nword_match_cr = compute(word_similar_share_cr, train, 'word_match_cr.npy')\\nword_match_rare = compute(word_match_rare_function, id_train, 'word_match_rare.npy')\\n    \\nfeatures = features.assign(**{'Word_Match_cr' : word_match_cr})\\nfeatures = features.assign(**{'Word_Match_rare' : word_match_rare})\\n\\n#TEST\\n\\n#test(features)\")\n\n\n# ### Fase 5: Cosine Similarity\n# ---\n# \n# Un altro utile parametro per la similarità tra frasi è la Cosine similarity: una tecnica euristica per la misurazione della similitudine tra due vettori effettuata calcolando il coseno tra di loro.\n# \n# Per poterla applicare è quindi necessario convertire ciascuna frase in una `Bag of words`, cioè un'array di dimensione pari al numero di parole distinte presenti all'interno del dataset. In questo array la posizione i-esima è settata a 1 se la parola comprare nella frase, 0 altrimenti.\n# In pratica ciascuna frase è rappresentata come un vettore in uno spazio n-dimensionale (con n pari alla dimensione di ciascuna `Bag of words`)\n# A questo punto si applica semplicemente la cosine similarity tra i due vettori ottenuti\n\n# In[13]:\n\n\n# start = time.time()\n\n# #bag words size\n# dim = len(dictionary.keys())\n# print(\"bag words size: {}\".format(dim))\n\n# #converte ogni frase in una bag of words da usare per la cosine similarity\n# def cosineConversion(sentence):\n#     s = np.zeros(dim)\n#     for w in sentence:\n#         s[w] = 1\n#     return s\n    \n# #simple wrap for cosineConversion\n# def cosineConversion_wrap(data):\n#     c1 = []\n#     c2 = []\n#     for sent1 in data['question1']:\n#         s1 = cosineConversion(sent1)\n#         c1.append(s1)\n\n#     for sent2 in data['question2']:\n#         s2 = cosineConversion(sent2)\n#         c2.append(s2)\n\n#     return c1, c2\n\n# #calculate Cosine Similarity\n# def cosineSimilarity(row):\n#     a = row['question1']\n#     b = row['question2']\n\n#     cos_sim = dot(a, b)/(norm(a)*norm(b))\n\n#     return cos_sim\n\n\n\n# cosine1, cosine2 = cosineConversion_wrap(id_train)\t\n\n# cosine_data = pd.DataFrame({\n#             'id': train['id'],\n#             'question1': cosine1,\n#             'question2': cosine2\n#             })\n\n# mid = time.time()\n\n# print('Cosine Similarity dataset: {}'.format(mid - start))\n\n# cosine_similarity = cosine_data.apply(cosineSimilarity, axis=1, raw=True)\n\n# features_tmp = features.copy().assign(**{'Cosine Similarity' : cosine_similarity})\n\n# end = time.time()\n# print('Cosine Similarity Algorithm: {}'.format(end - mid))\n\n# #TEST\n\n# test(features_tmp)\n\n\n# Sfortunatamente questa prima versione dell'algoritmo occupa troppa memoria \n\n# ### Fase 5B: cosine similarity migliorata\n# ---\n# Questa versione dell'algoritmo è più efficiente rispetto alla precedente e occupa molta meno memoria. Inoltre invece che far assumere a ciascun elemento della `Bag of words` i valori 0/1, `Sentence[w]` varrà  `n` cioè il numero di apparizioni della data parola all'interno della frase\n\n# In[14]:\n\n\nfrom numpy.linalg import norm\n\n#bag words size\ndim = len(dictionary.keys())\n\ndef cosineConversion(sentence):\n    s = np.zeros(dim, dtype=np.int8)\n    for w in sentence:\n        s[w] = s[w] + 1\n    return s\n\ndef cosineSimilarity(data, results, i):\n    res = []\n    for row in data.itertuples():   \n        q1 = getattr(row, 'question1')\n        q2 = getattr(row, 'question2')\n    \n        a = cosineConversion(q1)\n        b = cosineConversion(q2)\n\n        cos_sim = np.dot(a, b)/(norm(a)*norm(b))\n\n        res.append(cos_sim)\n    results[i] = res\n\n    \n#cosine_similarity = split_work(cosineSimilarity, id_train)\n#features_tmp = features.assign(**{'Cosine Similarity' : cosine_similarity})\n\n#TEST\n\n#test(features_tmp)\n\n\n# ### Fase 5C: Cosine Similarity Sklearn\n# ---\n# \n# La `Cosine Similarity` sembrava un buon parametro ma l'algoritmo precedentemente utilizzato non dava il risultato sperato, così mi sono appoggiato all'algoritmo presente all'interno del pacchetto `Sklearn`\n\n# In[15]:\n\n\nget_ipython().run_cell_magic('time', '', \"from sklearn.feature_extraction.text import TfidfVectorizer as TF\\nfrom sklearn.metrics.pairwise import cosine_similarity\\n\\ndef cosineSimilarity(data, results, i):\\n    res = []\\n    for row in data.itertuples():   \\n        q1 = str(getattr(row, 'question1'))\\n        q2 = str(getattr(row, 'question2'))\\n\\n        vect = TF(min_df=1)\\n        tfidf = vect.fit_transform([q1, q2])\\n\\n        res.append((tfidf * tfidf.T).A[0,1])\\n    results[i] = res\\n    \\ndef cosineSimilarity2(data):\\n    vect = TF(min_df=1)\\n    l1 = data['question1']\\n    l2 = data['question2']\\n    res = []\\n    \\n    vect.fit(data['question1'] + data['question2'])\\n    for row in data.itertuples():   \\n        q1 = str(getattr(row, 'question1'))\\n        q2 = str(getattr(row, 'question2'))\\n\\n        tf1 = vect.transform(q1)\\n        tf2 = vect.transform(q2)\\n\\n        cs = cosine_similarity(tf1,tf2)\\n        res.append(cs)\\n\\n#cos_sim = compute(cosineSimilarity, train, 'cosine_similarity.npy')\\ncos_sim = cosineSimilarity2(train)\\nfeatures = features.assign(**{'cos_sim': cos_sim})\\n\\n#TEST\\n#test(features)\")\n\n\n# La cosine similarity calcolata da Sklearn risulta essere migliore rispetto a quella calcolata precedente\n\n# ### Fase 6: Spacy Sentence similarity\n# ---\n# \n# La libreria Spacy prevede la possibilità di calcolare direttamente un indice di similarità tra frasi, questo si va ad aggiungere ai parametri precedenti \n\n# In[16]:\n\n\nget_ipython().run_cell_magic('time', '', \"\\ndef sentenceSimilarity(data, results, i):\\n    res = []\\n    for row in data.itertuples():   \\n        q1s = getattr(row, 'question1')\\n        q2s = getattr(row, 'question2')\\n    \\n        q1 = nlp(str(q1s))\\n        q2 = nlp(str(q2s))\\n\\n        res.append(q1.similarity(q2))\\n    results[i] = res\\n\\nspacy_sim = compute(sentenceSimilarity, train, 'spacy_similarity.npy')\\nfeatures = features.assign(**{'spacy_sim': spacy_sim})     \\n\\n#TEST\\n\\n#test(features)\\n\\nfeatures_set = features\")\n\n\n# ## Recap\n# ---\n# \n# I parametri finora individuati sono:\n# * features di base\n# * LCS\n# * jaccard common/rare\n# * cosine similarity (Sklearn)\n# * Spacy sentence similarity\n# \n# essi risultano ottimi per l'individuazione di frasi non duplicate, risulta invece più difficile individuare i doppioni\n\n# ## GridSearch\n\n# In[18]:\n\n\nfrom sklearn.model_selection import GridSearchCV\nfrom sklearn.metrics import make_scorer\n'''\nX_train = features[split]\nX_test = features[~split]\n\ny_train = duplicate[split]\ny_test = duplicate[~split]\n\npossible_parameters = {\n    'activation': ['identity', 'logistic', 'tanh', 'relu'],\n    'solver': ['lbfgs', 'sgd', 'adam']\n}\n\nalg = MLPClassifier()\nloss_f = make_scorer(log_loss, greater_is_better=False, needs_proba=True)\n\n# The GridSearchCV is itself a classifier\n# we fit the GridSearchCV with the training data\n# and then we use it to predict on the test set\nclf = GridSearchCV(alg, possible_parameters, n_jobs=4, scoring=loss_f) # n_jobs=4 means we parallelize the search over 4 threads\nclf.fit(X_train, y_train)\n\ny_pred = clf.predict_proba(X_test)\nlogLoss = log_loss(y_test, y_pred)\n\nlogLoss\n'''\n\n\n# In[ ]:\n\n\n'''\ncv = clf.cv_results_\ntab = pd.DataFrame({\n    'mean_fit_time': cv['mean_fit_time'],\n    'mean_score_time': cv['mean_score_time'],\n    'mean_test_score': cv['mean_test_score'],\n    'mean_train_score': cv['mean_train_score'],\n    'param_activation': cv['param_activation'],\n    'param_solver': cv['param_solver'],\n    'rank_test_score': cv['rank_test_score']\n})\n\ntab.sort_values(['rank_test_score']).head(3)\n'''\n\n\n# In[26]:\n\n\nget_ipython().run_cell_magic('time', '', \"\\nfrom sklearn.model_selection import GridSearchCV\\nfrom sklearn.metrics import make_scorer\\n\\nalg = MLPClassifier(solver='adam', activation='logistic')\\nloss_f = make_scorer(log_loss, greater_is_better=False, needs_proba=True)\\n\\nX_train = features[split]\\nX_test = features[~split]\\n\\ny_train = duplicate[split]\\ny_test = duplicate[~split]\\n\\npossible_parameters = {\\n    'alpha': [0.0001, 0.00005],\\n    'batch_size': [100, 50],\\n    'learning_rate_init': [0.001, 0.0005],\\n    'beta_1': [0.9, 0.99],\\n    'beta_2': [0.999, 0.5],\\n    'epsilon': [5e-9, 2e-9]\\n}\\n\\nclf2 = GridSearchCV(alg, possible_parameters, n_jobs=4, scoring=loss_f) # n_jobs=4 means we parallelize the search over 4 threads\\nclf2.fit(X_train, y_train)\\n\\ny_pred = clf2.predict_proba(X_test)\\nlogLoss = log_loss(y_test, y_pred)\\n\\nlogLoss\")\n\n\n# In[28]:\n\n\ncv = clf2.cv_results_\ntab = pd.DataFrame({\n    'mean_fit_time': cv['mean_fit_time'],\n    'mean_score_time': cv['mean_score_time'],\n    'mean_test_score': cv['mean_test_score'],\n    'mean_train_score': cv['mean_train_score'],\n    'param_alpha': cv['param_alpha'],\n    'param_batch_size': cv['param_batch_size'],\n    'param_learning_rate_init': cv['param_learning_rate_init'],\n    'rank_test_score': cv['rank_test_score'],\n    'param_beta_1': cv['param_beta_1'],\n    'param_epsilon': cv['param_epsilon']\n})\n\ntab.sort_values(['rank_test_score']).head(3)\n\n\n# ## Random Forest Classifier\n\n# In[39]:\n\n\nget_ipython().run_cell_magic('time', '', \"from sklearn.ensemble import RandomForestClassifier\\n\\nrf = RandomForestClassifier(random_state=0, n_jobs=4)\\n\\npossible_parameters = {\\n    'max_depth': [x for x in range(1, 20, 1)],\\n    'criterion': ['gini', 'entropy'],\\n    'max_features': ['auto', 'log2', None]\\n}\\n\\nclf = GridSearchCV(rf, possible_parameters, n_jobs=4, scoring=loss_f)\\n\\nclf.fit(X_train, y_train)\")\n\n\n# In[42]:\n\n\ny_pred = clf.predict_proba(X_test)\nlogLoss = log_loss(y_test, y_pred)\n\nlogLoss\n\n\n# Max_depth = 2, gini: 0.5456\n\n# In[41]:\n\n\ncv_rf = clf.cv_results_\ntab = pd.DataFrame({\n    'mean_fit_time': cv_rf['mean_fit_time'],\n    'mean_score_time': cv_rf['mean_score_time'],\n    'mean_test_score': cv_rf['mean_test_score'],\n    'mean_train_score': cv_rf['mean_train_score'],\n    'param_max_depth': cv_rf['param_max_depth'],\n    'param_criterion': cv_rf['param_criterion'],\n    'param_max_features': cv_rf['param_max_features'],\n    'rank_test_score': cv_rf['rank_test_score'],\n})\n\ntab.sort_values(['rank_test_score']).head(3)\n\n\n# ## Normalize Data\n\n# In[22]:\n\n\nfrom sklearn.preprocessing import MinMaxScaler\nimport warnings\nwarnings.filterwarnings('ignore')\n\nfeatures_scaled = pd.DataFrame(columns = list(features))\n\nletters_scaler = MinMaxScaler()\nwords_scaler = MinMaxScaler()\n\nletters_scaler.fit(features['q1_letters'] + features['q2_letters'])\nfeatures_scaled['q1_letters'] = letters_scaler.transform(features['q1_letters'])\nfeatures_scaled['q2_letters'] = letters_scaler.transform(features['q2_letters'])\n\nwords_scaler.fit(features['q1_words'] + features['q2_words'])\nfeatures_scaled['q1_words'] = words_scaler.transform(features['q1_words'])\nfeatures_scaled['q2_words'] = words_scaler.transform(features['q2_words'])\n\nfor feat in  ['LCS', 'Word_Match_cr', 'Word_Match_rare', 'cos_sim', 'spacy_sim']:\n    features_scaled[feat] = MinMaxScaler().fit_transform(features[feat])\n\n\n# ### MLPClassifier\n\n# In[24]:\n\n\nfrom sklearn.model_selection import GridSearchCV\nfrom sklearn.metrics import make_scorer\n\nalg = MLPClassifier(solver='adam', activation='logistic')\nloss_f = make_scorer(log_loss, greater_is_better=False, needs_proba=True)\n\nX_train = features_scaled[split]\nX_test = features_scaled[~split]\n\ny_train = duplicate[split]\ny_test = duplicate[~split]\n\npossible_parameters = {\n    'alpha': [0.0001, 0.00005],\n    'batch_size': [100, 50],\n    'learning_rate_init': [0.001, 0.0005],\n    'beta_1': [0.9, 0.99],\n    'beta_2': [0.999, 0.5],\n    'epsilon': [5e-9, 2e-9]\n}\n\nmlp = GridSearchCV(alg, possible_parameters, n_jobs=4, scoring=loss_f) # n_jobs=4 means we parallelize the search over 4 threads\nmlp.fit(X_train, y_train)\n\n\n# In[25]:\n\n\ncv = mlp.cv_results_\ntab = pd.DataFrame({\n    'mean_fit_time': cv['mean_fit_time'],\n    'mean_score_time': cv['mean_score_time'],\n    'mean_test_score': cv['mean_test_score'],\n    'mean_train_score': cv['mean_train_score'],\n    'param_alpha': cv['param_alpha'],\n    'param_batch_size': cv['param_batch_size'],\n    'param_learning_rate_init': cv['param_learning_rate_init'],\n    'rank_test_score': cv['rank_test_score'],\n    'param_beta_1': cv['param_beta_1'],\n    'param_epsilon': cv['param_epsilon']\n})\n\ntab.sort_values(['rank_test_score']).head(3)\n\n\n# ### Random Forest\n\n# In[29]:\n\n\nfrom sklearn.ensemble import RandomForestClassifier\n\nrf = RandomForestClassifier(random_state=0, n_jobs=4)\n\npossible_parameters = {\n    'max_depth': [x for x in range(1, 20, 1)],\n    'criterion': ['gini', 'entropy'],\n    'max_features': ['auto', 'log2', None]\n}\n\npossible_parameters['max_depth'].append(None)\n\nclf = GridSearchCV(rf, possible_parameters, n_jobs=4, scoring=loss_f)\n\nclf.fit(X_train, y_train)\n\n\n# In[30]:\n\n\ncv_rf = clf.cv_results_\ntab = pd.DataFrame({\n    'mean_fit_time': cv_rf['mean_fit_time'],\n    'mean_score_time': cv_rf['mean_score_time'],\n    'mean_test_score': cv_rf['mean_test_score'],\n    'mean_train_score': cv_rf['mean_train_score'],\n    'param_max_depth': cv_rf['param_max_depth'],\n    'param_criterion': cv_rf['param_criterion'],\n    'param_max_features': cv_rf['param_max_features'],\n    'rank_test_score': cv_rf['rank_test_score'],\n})\n\ntab.sort_values(['rank_test_score']).head(3)\n\n\n# In[21]:\n\n\nX_train = features[split]\nX_test = features[~split]\n\ny_train = duplicate[split]\ny_test = duplicate[~split]\n\n\n# ### Naive Bayes Gaussian\n\n# In[33]:\n\n\nfrom sklearn.naive_bayes import GaussianNB\n\ngnb = GaussianNB()\ngnb.fit(X_train, y_train)\n\ny_pred = gnb.predict_proba(X_test)\nlogLoss = log_loss(y_test, y_pred)\n\nlogLoss\n\n\n# ### Quadratic Discriminant\n\n# In[34]:\n\n\nfrom sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis\n\nqda = QuadraticDiscriminantAnalysis()\nqda.fit(X_train, y_train)\n\ny_pred = qda.predict_proba(X_test)\nlogLoss = log_loss(y_test, y_pred)\n\nlogLoss\n\n\n# ### Support Vector Classifier\n\n# In[ ]:\n\n\nget_ipython().run_cell_magic('time', '', '\\nfrom sklearn import svm\\n\\nsvc = svm.SVC()\\nsvc.fit(X_train, y_train)\\n\\ny_pred = svc.predict_proba(X_test)\\nlogLoss = log_loss(y_test, y_pred)\\n\\nlogLoss')\n\n\n# ## FC Network\n\n# In[17]:\n\n\nget_ipython().run_cell_magic('time', '', \"\\nfeatures_train = features[split]\\nfeatures_test = features[~split]\\n\\nlabels_train = duplicate[split]\\nlabels_test = duplicate[~split]\\n\\nfeatures_train = np.asmatrix(features_train)\\nfeatures_test = np.asmatrix(features_test)\\n\\nlabels_train = np.asmatrix(labels_train)\\nlabels_test = np.asmatrix(labels_test)\\n\\nlabels_train = kUtils.to_categorical(labels_train, 2)\\nlabels_test = kUtils.to_categorical(labels_test, 2)\\n\\n#architecture\\nmodel = Sequential()\\nmodel.add(Dense(300, activation= 'elu', input_dim = features_train.shape[1]))\\n#model.add(Dropout(0.2))\\nmodel.add(BatchNormalization())\\nfor i in range(8):\\n    model.add(Dense(200, activation= 'elu'))\\n    #model.add(Dropout(0.2))\\n    #model.add(BatchNormalization())\\nmodel.add(Dense(2, activation= 'softmax'))\\n\\nmodel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\\n\\nhistory= model.fit(features_train, labels_train, batch_size=128, epochs=20, verbose=2, validation_data=(features_test, labels_test))\\n\\nscore = model.evaluate(features_test, labels_test, verbose=0)\\n\\nprint('Log loss: {}'.format(score[0]))\\nprint('Accuracy: {}'.format(score[1]))\")\n\n\n# ### Add Dropout and Normalization\n\n# In[19]:\n\n\nget_ipython().run_cell_magic('time', '', \"\\nfeatures_train = features[split]\\nfeatures_test = features[~split]\\n\\nlabels_train = duplicate[split]\\nlabels_test = duplicate[~split]\\n\\nfeatures_train = np.asmatrix(features_train)\\nfeatures_test = np.asmatrix(features_test)\\n\\nlabels_train = np.asmatrix(labels_train)\\nlabels_test = np.asmatrix(labels_test)\\n\\nlabels_train = kUtils.to_categorical(labels_train, 2)\\nlabels_test = kUtils.to_categorical(labels_test, 2)\\n\\n#architecture\\nmodel = Sequential()\\nmodel.add(Dense(300, activation= 'elu', input_dim = features_train.shape[1]))\\nmodel.add(Dropout(0.2))\\nmodel.add(BatchNormalization())\\nfor i in range(8):\\n    model.add(Dense(200, activation= 'elu'))\\n    model.add(Dropout(0.2))\\n    model.add(BatchNormalization())\\nmodel.add(Dense(2, activation= 'softmax'))\\n\\nmodel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\\n\\nhistory= model.fit(features_train, labels_train, batch_size=128, epochs=20, verbose=2, validation_data=(features_test, labels_test))\\n\\nscore = model.evaluate(features_test, labels_test, verbose=0)\\n\\nprint('Log loss: {}'.format(score[0]))\\nprint('Accuracy: {}'.format(score[1]))\")\n\n\n# ### Esperimenti\n\n# In[ ]:\n\n\nget_ipython().run_cell_magic('time', '', \"\\nfeatures_train = features[split]\\nfeatures_test = features[~split]\\n\\nlabels_train = duplicate[split]\\nlabels_test = duplicate[~split]\\n\\nfeatures_train = np.asmatrix(features_train)\\nfeatures_test = np.asmatrix(features_test)\\n\\nlabels_train = np.asmatrix(labels_train)\\nlabels_test = np.asmatrix(labels_test)\\n\\nlabels_train = kUtils.to_categorical(labels_train, 2)\\nlabels_test = kUtils.to_categorical(labels_test, 2)\\n\\n#architecture\\nmodel = Sequential()\\nmodel.add(Dense(400, activation= 'elu', input_dim = features_train.shape[1]))\\nfor i in range(13):\\n    model.add(Dense(400, activation= 'elu'))\\nmodel.add(Dense(2, activation= 'softmax'))\\n\\nmodel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\\n\\nhistory= model.fit(features_train, labels_train, batch_size=128, epochs=20, verbose=2, validation_data=(features_test, labels_test))\\n\\nscore = model.evaluate(features_test, labels_test, verbose=0)\\n\\nprint('Log loss: {}'.format(score[0]))\\nprint('Accuracy: {}'.format(score[1]))\")\n\n", "meta": {"hexsha": "374cb3c2bc044372458ff16235e577dd1734b59b", "size": 38575, "ext": "py", "lang": "Python", "max_stars_repo_path": "Machine Learning/Sklearn.py", "max_stars_repo_name": "cece95/Tesi", "max_stars_repo_head_hexsha": "6cfe1babf907315f427d05c4b8dcc0b40b7bcaba", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Machine Learning/Sklearn.py", "max_issues_repo_name": "cece95/Tesi", "max_issues_repo_head_hexsha": "6cfe1babf907315f427d05c4b8dcc0b40b7bcaba", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Machine Learning/Sklearn.py", "max_forks_repo_name": "cece95/Tesi", "max_forks_repo_head_hexsha": "6cfe1babf907315f427d05c4b8dcc0b40b7bcaba", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.7478354978, "max_line_length": 2501, "alphanum_fraction": 0.6685418017, "include": true, "reason": "import numpy,from numpy", "num_tokens": 10714, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44939263446475963, "lm_q2_score": 0.144148856709452, "lm_q1q2_score": 0.06477943447174377}}
{"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n\"\"\"\nSome example's of good and bad plotting practices\n\t\nResources:\n\tFor all the great color paletes for python, got to\n\thttps://jiffyclub.github.io/palettable/\n\n\tFor more infomation about which colormaps are safe, see\n\thttp://colorbrewer2.org/\n\tNote: all colorbrewer colormaps are in the palettable package\n\n\tFor general infomation about map making see:\n\thttp://gisgeography.com/map-elements-how-to-guide-map-making/\n\thttp://www.esri.com/news/arcuser/0911/making-a-map-meaningful.html\n\n\tFor a detailed guide to mapmaking see the Mapbox guide pdf in the repo\n\"\"\"\n__title__ = \"Plotting and map making\"\n__author__ = \"Arden Burrell\"\n__version__ = \"1.0 (19.01.2018)\"\n__email__ = \"arden.burrell@unsw.edu.au\"\n\n\n#==============================================================================\n\n# general modules\n# import os, sys # check for files and so on\nimport numpy as np # array manipulations\n\n# plotting modules \nimport matplotlib.pyplot as plt\n#import matplotlib.cm as cm\nimport matplotlib.colors as mpc\nfrom matplotlib import ticker\n# import matplotlib as mpl\nimport pdb\n# for mapping \nfrom mpl_toolkits.basemap import Basemap\n\n# for all the awesome color palets!!!!!!!!!!\nimport palettable \n\n#==============================================================================\n# =========== Main function ==========\n\ndef main():\n\t\"\"\"\n\n\tCall the demonstration functions in order\n\n\t\"\"\"\n\t# Show the mapping of years \n\tyearmapper()\n\n\t# Map a variable that diverges\n\tdivergingmap()\n\t\n\t# Map a variable that is in groups\n\tgroupmap()\n\n\t# Map a variable that is sequental \n\tsequentialmap()\n\n\n#==============================================================================\n# =========== plotting functions ==========\ndef mapper(\n\timage, cmap, vmin, vmax, region=\"global\", title=None, \n\ttks=False, tckstr=None, norm=False, nancolour='dimgrey'\n\t):\n\t\"\"\"\n\tA general mapping function that can be used to generate many different\n\tmap types  \n\t\"\"\"\n\n\t# ===== set the spatial cordinates of the grid, mask the ocean and draw coastlines =====\n\t# Note: \n\t# \tbecause all of the imput datastes are numpy arrays, the lon and lat bounds \n\t# \tand the spatial projection (epsg) are hard coded. This infomation can be \n\t# \tcan be pulled automitically from nectdf, geoTif's and other raster data\n\tif region == \"global\":\n\t\t# Set the map frame\n\t\tmap = Basemap(llcrnrlon=-180.0,llcrnrlat=-90.0,urcrnrlon=180,urcrnrlat=90.0, resolution = 'h', epsg=4326)\n\t\t#adds national borders \n\t\tmap.drawcountries() \n\telif region == \"australia\":\n\t\t# Set the map frame\n\t\tmap = Basemap(llcrnrlon=112.0,llcrnrlat=-44.5,urcrnrlon=156.25,urcrnrlat=-10, resolution = 'h', epsg=4326)\n\t\tmap.drawlsmask(land_color='none', )\n\telif region == \"mongolia\":\n\t\t# Set the map frame\n\t\tmap = Basemap(llcrnrlon=85.0,llcrnrlat=40,urcrnrlon=120,urcrnrlat=52, resolution = 'h', epsg=4326)\n\t\tmap.drawlsmask(land_color='none', )\n\t\t# Draw national borders with a thicker line\n\t\tmap.drawcountries(linewidth = 1.25) \n\telse:\n\t\tsys.exit(\"Unknown Grid region\")\n\t# Set the color or NaN's in the data\n\tmap.drawmapboundary(fill_color=nancolour) #used to be grey\n\t# For land data, it is usefull to mask lakes etc\n\tmap.fillcontinents(color= 'none', lake_color='white')\n\t# Add all of the coastlines to the map\n\tmap.drawcoastlines()\n\t# Add the US and Australian state lines (Doesn't yet support other counteries)\n\tmap.drawstates()\n\n\t# ====== Add mpc.BoundaryNorm made custom cmaps =====\n\tif norm == False:\n\t\tmap.imshow(np.flipud(image), cmap=cmap, vmin=vmin, vmax=vmax)\n\telse:\n\t\tmap.imshow(np.flipud(image), cmap=cmap, vmin=vmin, vmax=vmax, norm=norm)\n\t\n\tcb = map.colorbar()\n\t\n\t# ===== Move and adjust the number and location of colorbar ticks =====\n\tif tks == False:\n\t\ttick_locator = ticker.MaxNLocator(nbins=20)\n\telif type(tks)==int:\n\t\ttick_locator = ticker.MaxNLocator(nbins=tks)\n\telse:\n\t\ttick_locator = ticker.MaxNLocator(nbins=vmax-vmin)\n\t# Add the changes to the colorbar\n\tcb.locator = tick_locator\n\tcb.update_ticks()\n\n\t# ===== Overwrite the tick labels and replace them with user defined =====\n\tif tckstr is not None:\n\t\tcb.ax.set_yticklabels(tckstr) \n\n\t# ===== add in the Graticules (lon lat grid lines) ======\n\tif region == \"global\":\n\t\tmap.drawparallels(np.arange(-90, 90, 10),labels=[1,0,0,0], dashes=[1,2])\n\t\tmap.drawmeridians(np.arange(-180, 180, 20),labels=[0,0,0,1], dashes=[1,2])\n\telif region == \"australia\":\n\t\tmap.drawparallels(np.arange(-50, -10, 10),labels=[1,0,0,0], dashes=[1,2])\n\t\tmap.drawmeridians(np.arange(110, 156.25, 10),labels=[0,0,0,1], dashes=[1,2])\n\telif region == \"mongolia\":\n\t\tmap.drawparallels(np.arange(40, 60, 5),labels=[1,0,0,0], dashes=[1,2])\n\t\tmap.drawmeridians(np.arange(80, 120, 5),labels=[0,0,0,1], dashes=[1,2])\n\t\n\t# ===== Show the plot =====\n\tplt.show()\n\n\ndef yearmapper():\n\t\"\"\"\n\tDemonstrate how to map a variable where there a many subdevisions,\n\tin this case the years of a breakpoint detected by the TSS.RESTREND method\n\tapplied to GIMMSv3.1g NDVI data over mongolia. \n\n\tIn this data:\n\t\t- Nan values mean the method failed\n\t\t- 0 value means that the method detected no breakpoints\n\t\t- else: the year in which a ecosystem breakpoint occured \n\t\"\"\"\n\n\t# Load the data from a numpy array \n\tmong_bp = np.load(\"./Data/Mongolia_breakpoint_years.npy\")\n\n\t# ===== Make a naive plot =====\n\t# Comments: this plot is meant to be terrible, \n\t# \tAll the values that are relevant are hidden\n\t# \tThere is no colorbar\n\t\n\t# Set the figure number\n\t#\tThis isnt strictly nessary, but usefull if you \n\t# \twant to generate multiple plots then show them together \n\tplt.figure(1) \n\t# Make the plot\n\tplt.imshow(mong_bp)\n\tplt.show()\n\n\t# pdb.set_trace()\n\t\n\t# ===== Make a slightly less terrible one =====\n\t# Comments: this plot easier to read but not a map \n\t# \tAdded bounds, and a much better colormap\n\t# \tThe colormap is still continuous (hard to read)\n\t\n\t#Hard code the start and end years, (these can be determined automatically) \n\tvmin = 1987\n\tvmax = 2011\n\t# Get a colormap thats a bit better and tweak it\n\tcmap = plt.cm.jet \n\tcmap.set_under('w') #sets values <vmin to white in the plot\n\tcmap.set_bad('dimgrey') \n\n\t# Create the image\n\n\tplt.imshow(mong_bp, vmin = vmin, vmax = vmax, cmap=cmap)\n\tplt.colorbar()\n\tplt.show()\n\t\n\t# ===== Turn this into a proper map with a segmented colorbar =====\n\tplt.figure(2) \n\t# Comments: Now its an actual map\n\t# \tSegmented colorbars are easier to read\n\t# \tThe colormap is still continuous (hard to read)\n\n\t# +++++ turn a continuous colormap into a segmented one ++++\n\t# The continuous color map \n\tcmap = plt.cm.jet\n\t# extract all colors from the cmap\n\tcmaplist = [cmap(i) for i in range(cmap.N)]\n\tcmap = cmap.from_list('Custom cmap', cmaplist, cmap.N)\n\t# Define the coverage and segments (max values, min values, number of segments)\n\tbounds = np.linspace(vmin, vmax, vmax-(vmin-1))\n\t# Select the colors for each bound using BoundaryNorm function\n\tnorm = mpc.BoundaryNorm(bounds, cmap.N)\n\t# set pixels below the vmin to color to be white\n\tcmap.set_under('w')\n\t# cmap.set_above('w') # set colors above the vmax value to a color\n\ttks = (vmax-vmin)/2+1\n\t\n\t# +++++ Pass the data and infomation the mapper function +++++\n\tmapper(mong_bp, cmap, vmin, vmax, region=\"mongolia\", tks=tks, norm=norm)\n\n\t# Note: There is almost no reason to use Jet in science, \n\t# this is one of very few exceptions. Use palettable ones instead!!!!! \n\ndef divergingmap():\n\t\"\"\"\n\tDemonstrate how to map a variable where the values diverge,\n\tin this case,  the total change in NDVI between 1982-2015 as \n\tdetected by the TSS.RESTREND method\tapplied to GIMMSv3.1g NDVI\n\tdata. \n\n\tIn this data:\n\t\t- Nan values mean the method failed\n\t\t- -1 values have no statistically significant change in vegetation\n\t\t- else: total change in NDVI (note:NDVI is normalised between 0 and 1) \n\t\"\"\"\n\n\t# ===== Load the data from a numpy array =====\n\tTC = np.load(\"./Data/Global_total_change.npy\")\n\n\t# ===== setup the mapping variables =====\n\t# set the min and max\n\tvmax = 0.3\n\tvmin = -0.3\n\t# Grab a diverging colormap from palettable\n\tcmap = mpc.ListedColormap(palettable.colorbrewer.diverging.PiYG_10.mpl_colors)\n\t# set the color of values of pixels with no significant change (have been set to -1)\n\tcmap.set_under('w')\n\t# This number needs to be adjusted to get the ticks tp line up\n\ttks=11\n\n\t# Generate the map \n\tmapper(TC, cmap, vmin, vmax, region=\"global\", tks=tks)\n\t\n\ndef sequentialmap():\n\t\"\"\"\n\tDemonstrate how to map a variable where the values are sequential.\n\tin this case,  the p between NDVI and rainfall detected by the \n\tTSS.RESTREND method\tapplied to GIMMSv3.1g NDVI data. \n\n\tIn this data:\n\t\t- NaN values mean the method failed\n\t\t- else: and Rsquared value between 0 and 1 \n\t\"\"\"\n\n\t# ===== Load the data from a numpy array =====\n\tpval = np.load(\"./Data/Global_pval.npy\")\n\t\n\t# ===== setup the mapping variables =====\n\t# set the min and max\n\tvmax = 1\n\tvmin = 0\n\t# Grab a sequential colormap from palettable\n\tcmap=mpc.ListedColormap(palettable.cmocean.sequential.Thermal_20_r.mpl_colors)\n\t# set the color of values of pixels with no significant change (have been set to -1)\n\t# cmap.set_under('w')\n\t# set the number of ticks\n\ttks=21\n\t\n\t# ===== Generate the map =====\n\tmapper(pval, cmap, vmin, vmax, region=\"global\", tks=tks)\n\n\t# Note: \n\t# \tThis is a terrible plot. Hopefully MS will\n\t# \tupdate the script with a function that allows \n\t#\tcolormas to be scalled. \n\n\t\ndef groupmap():\n\t\"\"\"\n\tDemonstrate how to map a variable where the values are in \n\tclassified groups. in this case,  the comparison of TSS.RESTREND \n\tdirection between GIMMSv3.1g NDVI and VOD data. \n\n\tIn this data:\n\t\t- The numbers refer to groups (0 - 8)\n\t\"\"\"\n\n\t# ===== Load the data from a numpy array =====\n\tgroups = np.load(\"./Data/Global_classes.npy\")\n\t# show what the data looks like\n\tplt.imshow(groups)\n\tplt.colorbar()\n\tplt.show()\n\t\n\t# ===== setup the mapping variables =====\n\t# set the min and max\n\tvmin = -0.5\n\tvmax = 8.5\n\t# Create the labels\n\tlabel2=['No Change', 'Both Dec', 'Both Inc','NDVI Inc, VOD Dec','NDVI Inc, VOD stable', 'NDVI stable, VOD Dec','VOD Inc, NDVI Dec', 'VOD Inc, NDVI stable', 'VOD stable, NDVI Dec']\n\t# Create a custom discrete colourmap from hex values \n\tcmaphex = ['#d1cdca','#AF0627', '#ffffff','#1a9850', '#91cf60','#d9ef8b','#6a51a3','#9e9ac8', '#cbc9e2'] \n\tcmap = mpc.ListedColormap(cmaphex)\n\t# Set the color under\n\tcmap.set_under('w')\n\t\n\t# ===== Generate the map =====\n\tmapper(groups, cmap, vmin, vmax, region=\"global\", tks=True, tckstr = label2)\n\t\n\n\nif __name__ == '__main__':\n\tmain()", "meta": {"hexsha": "c9b4942b0b66e6afb92b96de73d38de437b99dcf", "size": 10454, "ext": "py", "lang": "Python", "max_stars_repo_path": "Plotting_and_mapping/Mapping_and_colours_ArdenB.py", "max_stars_repo_name": "ManonSabot/CCRCexamples", "max_stars_repo_head_hexsha": "5b7eb66d348e8820c07f74f3aeb4588f15996151", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Plotting_and_mapping/Mapping_and_colours_ArdenB.py", "max_issues_repo_name": "ManonSabot/CCRCexamples", "max_issues_repo_head_hexsha": "5b7eb66d348e8820c07f74f3aeb4588f15996151", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Plotting_and_mapping/Mapping_and_colours_ArdenB.py", "max_forks_repo_name": "ManonSabot/CCRCexamples", "max_forks_repo_head_hexsha": "5b7eb66d348e8820c07f74f3aeb4588f15996151", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-27T07:39:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-27T07:39:29.000Z", "avg_line_length": 32.2654320988, "max_line_length": 180, "alphanum_fraction": 0.6818442701, "include": true, "reason": "import numpy", "num_tokens": 3054, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41489884579676883, "lm_q2_score": 0.15610488959337065, "lm_q1q2_score": 0.06476773851552152}}
{"text": "\"\"\"\n`Introduction <introyt1_tutorial.html>`_ ||\n**Tensors** ||\n`Autograd <autogradyt_tutorial.html>`_ ||\n`Building Models <modelsyt_tutorial.html>`_ ||\n`TensorBoard Support <tensorboardyt_tutorial.html>`_ ||\n`Training Models <trainingyt_tutorial.html>`_ ||\n`Model Understanding <captumyt_tutorial.html>`_\n\nIntroduction to PyTorch Tensors\n===============================\n\nFollow along with the video below or on `youtube <https://www.youtube.com/watch?v=r7QDUPb2dCM>`__.\n\n.. raw:: html\n\n   <div style=\"margin-top:10px; margin-bottom:10px;\">\n     <iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/r7QDUPb2dCM\" frameborder=\"0\" allow=\"accelerometer; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n   </div>\n\nTensors are the central data abstraction in PyTorch. This interactive\nnotebook provides an in-depth introduction to the ``torch.Tensor``\nclass.\n\nFirst things first, let’s import the PyTorch module. We’ll also add\nPython’s math module to facilitate some of the examples.\n\n\"\"\"\n\nimport torch\nimport math\n\n\n#########################################################################\n# Creating Tensors\n# ----------------\n# \n# The simplest way to create a tensor is with the ``torch.empty()`` call:\n# \n\nx = torch.empty(3, 4)\nprint(type(x))\nprint(x)\n\n\n##########################################################################\n# Let’s unpack what we just did:\n# \n# -  We created a tensor using one of the numerous factory methods\n#    attached to the ``torch`` module.\n# -  The tensor itself is 2-dimensional, having 3 rows and 4 columns.\n# -  The type of the object returned is ``torch.Tensor``, which is an\n#    alias for ``torch.FloatTensor``; by default, PyTorch tensors are\n#    populated with 32-bit floating point numbers. (More on data types\n#    below.)\n# -  You will probably see some random-looking values when printing your\n#    tensor. The ``torch.empty()`` call allocates memory for the tensor,\n#    but does not initialize it with any values - so what you’re seeing is\n#    whatever was in memory at the time of allocation.\n# \n# A brief note about tensors and their number of dimensions, and\n# terminology:\n# \n# -  You will sometimes see a 1-dimensional tensor called a\n#    *vector.* \n# -  Likewise, a 2-dimensional tensor is often referred to as a\n#    *matrix.* \n# -  Anything with more than two dimensions is generally just\n#    called a tensor.\n# \n# More often than not, you’ll want to initialize your tensor with some\n# value. Common cases are all zeros, all ones, or random values, and the\n# ``torch`` module provides factory methods for all of these:\n# \n\nzeros = torch.zeros(2, 3)\nprint(zeros)\n\nones = torch.ones(2, 3)\nprint(ones)\n\ntorch.manual_seed(1729)\nrandom = torch.rand(2, 3)\nprint(random)\n\n\n#########################################################################\n# The factory methods all do just what you’d expect - we have a tensor\n# full of zeros, another full of ones, and another with random values\n# between 0 and 1.\n# \n# Random Tensors and Seeding\n# ~~~~~~~~~~~~~~~~~~~~~~~~~~\n# \n# Speaking of the random tensor, did you notice the call to\n# ``torch.manual_seed()`` immediately preceding it? Initializing tensors,\n# such as a model’s learning weights, with random values is common but\n# there are times - especially in research settings - where you’ll want\n# some assurance of the reproducibility of your results. Manually setting\n# your random number generator’s seed is the way to do this. Let’s look\n# more closely:\n# \n\ntorch.manual_seed(1729)\nrandom1 = torch.rand(2, 3)\nprint(random1)\n\nrandom2 = torch.rand(2, 3)\nprint(random2)\n\ntorch.manual_seed(1729)\nrandom3 = torch.rand(2, 3)\nprint(random3)\n\nrandom4 = torch.rand(2, 3)\nprint(random4)\n\n\n############################################################################\n# What you should see above is that ``random1`` and ``random3`` carry\n# identical values, as do ``random2`` and ``random4``. Manually setting\n# the RNG’s seed resets it, so that identical computations depending on\n# random number should, in most settings, provide identical results.\n# \n# For more information, see the `PyTorch documentation on\n# reproducibility <https://pytorch.org/docs/stable/notes/randomness.html>`__.\n# \n# Tensor Shapes\n# ~~~~~~~~~~~~~\n# \n# Often, when you’re performing operations on two or more tensors, they\n# will need to be of the same *shape* - that is, having the same number of\n# dimensions and the same number of cells in each dimension. For that, we\n# have the ``torch.*_like()`` methods:\n# \n\nx = torch.empty(2, 2, 3)\nprint(x.shape)\nprint(x)\n\nempty_like_x = torch.empty_like(x)\nprint(empty_like_x.shape)\nprint(empty_like_x)\n\nzeros_like_x = torch.zeros_like(x)\nprint(zeros_like_x.shape)\nprint(zeros_like_x)\n\nones_like_x = torch.ones_like(x)\nprint(ones_like_x.shape)\nprint(ones_like_x)\n\nrand_like_x = torch.rand_like(x)\nprint(rand_like_x.shape)\nprint(rand_like_x)\n\n\n#########################################################################\n# The first new thing in the code cell above is the use of the ``.shape``\n# property on a tensor. This property contains a list of the extent of\n# each dimension of a tensor - in our case, ``x`` is a three-dimensional\n# tensor with shape 2 x 2 x 3.\n# \n# Below that, we call the ``.empty_like()``, ``.zeros_like()``,\n# ``.ones_like()``, and ``.rand_like()`` methods. Using the ``.shape``\n# property, we can verify that each of these methods returns a tensor of\n# identical dimensionality and extent.\n# \n# The last way to create a tensor that will cover is to specify its data\n# directly from a PyTorch collection:\n# \n\nsome_constants = torch.tensor([[3.1415926, 2.71828], [1.61803, 0.0072897]])\nprint(some_constants)\n\nsome_integers = torch.tensor((2, 3, 5, 7, 11, 13, 17, 19))\nprint(some_integers)\n\nmore_integers = torch.tensor(((2, 4, 6), [3, 6, 9]))\nprint(more_integers)\n\n\n######################################################################\n# Using ``torch.tensor()`` is the most straightforward way to create a\n# tensor if you already have data in a Python tuple or list. As shown\n# above, nesting the collections will result in a multi-dimensional\n# tensor.\n# \n# .. note::\n#      ``torch.tensor()`` creates a copy of the data.\n# \n# Tensor Data Types\n# ~~~~~~~~~~~~~~~~~\n# \n# Setting the datatype of a tensor is possible a couple of ways:\n# \n\na = torch.ones((2, 3), dtype=torch.int16)\nprint(a)\n\nb = torch.rand((2, 3), dtype=torch.float64) * 20.\nprint(b)\n\nc = b.to(torch.int32)\nprint(c)\n\n\n##########################################################################\n# The simplest way to set the underlying data type of a tensor is with an\n# optional argument at creation time. In the first line of the cell above,\n# we set ``dtype=torch.int16`` for the tensor ``a``. When we print ``a``,\n# we can see that it’s full of ``1`` rather than ``1.`` - Python’s subtle\n# cue that this is an integer type rather than floating point.\n# \n# Another thing to notice about printing ``a`` is that, unlike when we\n# left ``dtype`` as the default (32-bit floating point), printing the\n# tensor also specifies its ``dtype``.\n# \n# You may have also spotted that we went from specifying the tensor’s\n# shape as a series of integer arguments, to grouping those arguments in a\n# tuple. This is not strictly necessary - PyTorch will take a series of\n# initial, unlabeled integer arguments as a tensor shape - but when adding\n# the optional arguments, it can make your intent more readable.\n# \n# The other way to set the datatype is with the ``.to()`` method. In the\n# cell above, we create a random floating point tensor ``b`` in the usual\n# way. Following that, we create ``c`` by converting ``b`` to a 32-bit\n# integer with the ``.to()`` method. Note that ``c`` contains all the same\n# values as ``b``, but truncated to integers.\n# \n# Available data types include:\n# \n# -  ``torch.bool``\n# -  ``torch.int8``\n# -  ``torch.uint8``\n# -  ``torch.int16``\n# -  ``torch.int32``\n# -  ``torch.int64``\n# -  ``torch.half``\n# -  ``torch.float``\n# -  ``torch.double``\n# -  ``torch.bfloat``\n# \n# Math & Logic with PyTorch Tensors\n# ---------------------------------\n# \n# Now that you know some of the ways to create a tensor… what can you do\n# with them?\n# \n# Let’s look at basic arithmetic first, and how tensors interact with\n# simple scalars:\n# \n\nones = torch.zeros(2, 2) + 1\ntwos = torch.ones(2, 2) * 2\nthrees = (torch.ones(2, 2) * 7 - 1) / 2\nfours = twos ** 2\nsqrt2s = twos ** 0.5\n\nprint(ones)\nprint(twos)\nprint(threes)\nprint(fours)\nprint(sqrt2s)\n\n\n##########################################################################\n# As you can see above, arithmetic operations between tensors and scalars,\n# such as addition, subtraction, multiplication, division, and\n# exponentiation are distributed over every element of the tensor. Because\n# the output of such an operation will be a tensor, you can chain them\n# together with the usual operator precedence rules, as in the line where\n# we create ``threes``.\n# \n# Similar operations between two tensors also behave like you’d\n# intuitively expect:\n# \n\npowers2 = twos ** torch.tensor([[1, 2], [3, 4]])\nprint(powers2)\n\nfives = ones + fours\nprint(fives)\n\ndozens = threes * fours\nprint(dozens)\n\n\n##########################################################################\n# It’s important to note here that all of the tensors in the previous code\n# cell were of identical shape. What happens when we try to perform a\n# binary operation on tensors if dissimilar shape?\n# \n# .. note::\n#      The following cell throws a run-time error. This is intentional.\n# \n# ::\n#\n#    a = torch.rand(2, 3)\n#    b = torch.rand(3, 2)\n#\n#    print(a * b)\n#\n\n\n##########################################################################\n# In the general case, you cannot operate on tensors of different shape\n# this way, even in a case like the cell above, where the tensors have an\n# identical number of elements.\n# \n# In Brief: Tensor Broadcasting\n# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n# \n# .. note::\n#      If you are familiar with broadcasting semantics in NumPy\n#      ndarrays, you’ll find the same rules apply here.\n# \n# The exception to the same-shapes rule is *tensor broadcasting.* Here’s\n# an example:\n# \n\nrand = torch.rand(2, 4)\ndoubled = rand * (torch.ones(1, 4) * 2)\n\nprint(rand)\nprint(doubled)\n\n\n#########################################################################\n# What’s the trick here? How is it we got to multiply a 2x4 tensor by a\n# 1x4 tensor?\n# \n# Broadcasting is a way to perform an operation between tensors that have\n# similarities in their shapes. In the example above, the one-row,\n# four-column tensor is multiplied by *both rows* of the two-row,\n# four-column tensor.\n# \n# This is an important operation in Deep Learning. The common example is\n# multiplying a tensor of learning weights by a *batch* of input tensors,\n# applying the operation to each instance in the batch separately, and\n# returning a tensor of identical shape - just like our (2, 4) \\* (1, 4)\n# example above returned a tensor of shape (2, 4).\n# \n# The rules for broadcasting are:\n# \n# -  Each tensor must have at least one dimension - no empty tensors.\n# \n# -  Comparing the dimension sizes of the two tensors, *going from last to\n#    first:*\n# \n#    -  Each dimension must be equal, *or*\n# \n#    -  One of the dimensions must be of size 1, *or*\n# \n#    -  The dimension does not exist in one of the tensors\n# \n# Tensors of identical shape, of course, are trivially “broadcastable”, as\n# you saw earlier.\n# \n# Here are some examples of situations that honor the above rules and\n# allow broadcasting:\n# \n\na =     torch.ones(4, 3, 2)\n\nb = a * torch.rand(   3, 2) # 3rd & 2nd dims identical to a, dim 1 absent\nprint(b)\n\nc = a * torch.rand(   3, 1) # 3rd dim = 1, 2nd dim identical to a\nprint(c)\n\nd = a * torch.rand(   1, 2) # 3rd dim identical to a, 2nd dim = 1\nprint(d)\n\n\n#############################################################################\n# Look closely at the values of each tensor above: \n#\n# -  The multiplication operation that created ``b`` was \n#    broadcast over every “layer” of ``a``.\n# -  For ``c``, the operation was broadcast over ever layer and row of\n#    ``a`` - every 3-element column is identical. \n# -  For ``d``, we switched it around - now every *row* is identical,\n#    across layers and columns.\n# \n# For more information on broadcasting, see the `PyTorch\n# documentation <https://pytorch.org/docs/stable/notes/broadcasting.html>`__\n# on the topic.\n# \n# Here are some examples of attempts at broadcasting that will fail:\n#\n# .. note::\n#      The following cell throws a run-time error. This is intentional.\n# \n# ::\n#\n#    a =     torch.ones(4, 3, 2)\n#\n#    b = a * torch.rand(4, 3)    # dimensions must match last-to-first\n#\n#    c = a * torch.rand(   2, 3) # both 3rd & 2nd dims different\n#\n#    d = a * torch.rand((0, ))   # can't broadcast with an empty tensor\n#\n\n\n###########################################################################\n# More Math with Tensors\n# ~~~~~~~~~~~~~~~~~~~~~~\n# \n# PyTorch tensors have over three hundred operations that can be performed\n# on them.\n# \n# Here is a small sample from some of the major categories of operations:\n# \n\n# common functions\na = torch.rand(2, 4) * 2 - 1\nprint('Common functions:')\nprint(torch.abs(a))\nprint(torch.ceil(a))\nprint(torch.floor(a))\nprint(torch.clamp(a, -0.5, 0.5))\n\n# trigonometric functions and their inverses\nangles = torch.tensor([0, math.pi / 4, math.pi / 2, 3 * math.pi / 4])\nsines = torch.sin(angles)\ninverses = torch.asin(sines)\nprint('\\nSine and arcsine:')\nprint(angles)\nprint(sines)\nprint(inverses)\n\n# bitwise operations\nprint('\\nBitwise XOR:')\nb = torch.tensor([1, 5, 11])\nc = torch.tensor([2, 7, 10])\nprint(torch.bitwise_xor(b, c))\n\n# comparisons:\nprint('\\nBroadcasted, element-wise equality comparison:')\nd = torch.tensor([[1., 2.], [3., 4.]])\ne = torch.ones(1, 2)  # many comparison ops support broadcasting!\nprint(torch.eq(d, e)) # returns a tensor of type bool\n\n# reductions:\nprint('\\nReduction ops:')\nprint(torch.max(d))        # returns a single-element tensor\nprint(torch.max(d).item()) # extracts the value from the returned tensor\nprint(torch.mean(d))       # average\nprint(torch.std(d))        # standard deviation\nprint(torch.prod(d))       # product of all numbers\nprint(torch.unique(torch.tensor([1, 2, 1, 2, 1, 2]))) # filter unique elements\n\n# vector and linear algebra operations\nv1 = torch.tensor([1., 0., 0.])         # x unit vector\nv2 = torch.tensor([0., 1., 0.])         # y unit vector\nm1 = torch.rand(2, 2)                   # random matrix\nm2 = torch.tensor([[3., 0.], [0., 3.]]) # three times identity matrix\n\nprint('\\nVectors & Matrices:')\nprint(torch.cross(v2, v1)) # negative of z unit vector (v1 x v2 == -v2 x v1)\nprint(m1)\nm3 = torch.matmul(m1, m2)\nprint(m3)                  # 3 times m1\nprint(torch.svd(m3))       # singular value decomposition\n\n\n##################################################################################\n# This is a small sample of operations. For more details and the full inventory of\n# math functions, have a look at the\n# `documentation <https://pytorch.org/docs/stable/torch.html#math-operations>`__.\n# \n# Altering Tensors in Place\n# ~~~~~~~~~~~~~~~~~~~~~~~~~\n# \n# Most binary operations on tensors will return a third, new tensor. When\n# we say ``c = a * b`` (where ``a`` and ``b`` are tensors), the new tensor\n# ``c`` will occupy a region of memory distinct from the other tensors.\n# \n# There are times, though, that you may wish to alter a tensor in place -\n# for example, if you’re doing an element-wise computation where you can\n# discard intermediate values. For this, most of the math functions have a\n# version with an appended underscore (``_``) that will alter a tensor in\n# place.\n# \n# For example:\n# \n\na = torch.tensor([0, math.pi / 4, math.pi / 2, 3 * math.pi / 4])\nprint('a:')\nprint(a)\nprint(torch.sin(a))   # this operation creates a new tensor in memory\nprint(a)              # a has not changed\n\nb = torch.tensor([0, math.pi / 4, math.pi / 2, 3 * math.pi / 4])\nprint('\\nb:')\nprint(b)\nprint(torch.sin_(b))  # note the underscore\nprint(b)              # b has changed\n\n\n#######################################################################\n# For arithmetic operations, there are functions that behave similarly:\n# \n\na = torch.ones(2, 2)\nb = torch.rand(2, 2)\n\nprint('Before:')\nprint(a)\nprint(b)\nprint('\\nAfter adding:')\nprint(a.add_(b))\nprint(a)\nprint(b)\nprint('\\nAfter multiplying')\nprint(b.mul_(b))\nprint(b)\n\n\n##########################################################################\n# Note that these in-place arithmetic functions are methods on the\n# ``torch.Tensor`` object, not attached to the ``torch`` module like many\n# other functions (e.g., ``torch.sin()``). As you can see from\n# ``a.add_(b)``, *the calling tensor is the one that gets changed in\n# place.*\n# \n# There is another option for placing the result of a computation in an\n# existing, allocated tensor. Many of the methods and functions we’ve seen\n# so far - including creation methods! - have an ``out`` argument that\n# lets you specify a tensor to receive the output. If the ``out`` tensor\n# is the correct shape and ``dtype``, this can happen without a new memory\n# allocation:\n# \n\na = torch.rand(2, 2)\nb = torch.rand(2, 2)\nc = torch.zeros(2, 2)\nold_id = id(c)\n\nprint(c)\nd = torch.matmul(a, b, out=c)\nprint(c)                # contents of c have changed\n\nassert c is d           # test c & d are same object, not just containing equal values\nassert id(c), old_id    # make sure that our new c is the same object as the old one\n\ntorch.rand(2, 2, out=c) # works for creation too!\nprint(c)                # c has changed again\nassert id(c), old_id    # still the same object!\n\n\n##########################################################################\n# Copying Tensors\n# ---------------\n# \n# As with any object in Python, assigning a tensor to a variable makes the\n# variable a *label* of the tensor, and does not copy it. For example:\n# \n\na = torch.ones(2, 2)\nb = a\n\na[0][1] = 561  # we change a...\nprint(b)       # ...and b is also altered\n\n\n######################################################################\n# But what if you want a separate copy of the data to work on? The\n# ``clone()`` method is there for you:\n# \n\na = torch.ones(2, 2)\nb = a.clone()\n\nassert b is not a      # different objects in memory...\nprint(torch.eq(a, b))  # ...but still with the same contents!\n\na[0][1] = 561          # a changes...\nprint(b)               # ...but b is still all ones\n\n\n#########################################################################\n# **There is an important thing to be aware of when using ``clone()``.**\n# If your source tensor has autograd, enabled then so will the clone.\n# **This will be covered more deeply in the video on autograd,** but if\n# you want the light version of the details, continue on.\n# \n# *In many cases, this will be what you want.* For example, if your model\n# has multiple computation paths in its ``forward()`` method, and *both*\n# the original tensor and its clone contribute to the model’s output, then\n# to enable model learning you want autograd turned on for both tensors.\n# If your source tensor has autograd enabled (which it generally will if\n# it’s a set of learning weights or derived from a computation involving\n# the weights), then you’ll get the result you want.\n# \n# On the other hand, if you’re doing a computation where *neither* the\n# original tensor nor its clone need to track gradients, then as long as\n# the source tensor has autograd turned off, you’re good to go.\n# \n# *There is a third case,* though: Imagine you’re performing a computation\n# in your model’s ``forward()`` function, where gradients are turned on\n# for everything by default, but you want to pull out some values\n# mid-stream to generate some metrics. In this case, you *don’t* want the\n# cloned copy of your source tensor to track gradients - performance is\n# improved with autograd’s history tracking turned off. For this, you can\n# use the ``.detach()`` method on the source tensor:\n# \n\na = torch.rand(2, 2, requires_grad=True) # turn on autograd\nprint(a)\n\nb = a.clone()\nprint(b)\n\nc = a.detach().clone()\nprint(c)\n\nprint(a)\n\n\n#########################################################################\n# What’s happening here?\n# \n# -  We create ``a`` with ``requires_grad=True`` turned on. **We haven’t\n#    covered this optional argument yet, but will during the unit on\n#    autograd.**\n# -  When we print ``a``, it informs us that the property\n#    ``requires_grad=True`` - this means that autograd and computation\n#    history tracking are turned on.\n# -  We clone ``a`` and label it ``b``. When we print ``b``, we can see\n#    that it’s tracking its computation history - it has inherited\n#    ``a``\\ ’s autograd settings, and added to the computation history.\n# -  We clone ``a`` into ``c``, but we call ``detach()`` first.\n# -  Printing ``c``, we see no computation history, and no\n#    ``requires_grad=True``.\n# \n# The ``detach()`` method *detaches the tensor from its computation\n# history.* It says, “do whatever comes next as if autograd was off.” It\n# does this *without* changing ``a`` - you can see that when we print\n# ``a`` again at the end, it retains its ``requires_grad=True`` property.\n# \n# Moving to GPU\n# -------------\n# \n# One of the major advantages of PyTorch is its robust acceleration on\n# CUDA-compatible Nvidia GPUs. (“CUDA” stands for *Compute Unified Device\n# Architecture*, which is Nvidia’s platform for parallel computing.) So\n# far, everything we’ve done has been on CPU. How do we move to the faster\n# hardware?\n# \n# First, we should check whether a GPU is available, with the\n# ``is_available()`` method.\n# \n# .. note::\n#      If you do not have a CUDA-compatible GPU and CUDA drivers\n#      installed, the executable cells in this section will not execute any\n#      GPU-related code.\n# \n\nif torch.cuda.is_available():\n    print('We have a GPU!')\nelse:\n    print('Sorry, CPU only.')\n\n\n##########################################################################\n# Once we’ve determined that one or more GPUs is available, we need to put\n# our data someplace where the GPU can see it. Your CPU does computation\n# on data in your computer’s RAM. Your GPU has dedicated memory attached\n# to it. Whenever you want to perform a computation on a device, you must\n# move *all* the data needed for that computation to memory accessible by\n# that device. (Colloquially, “moving the data to memory accessible by the\n# GPU” is shorted to, “moving the data to the GPU”.)\n# \n# There are multiple ways to get your data onto your target device. You\n# may do it at creation time:\n# \n\nif torch.cuda.is_available():\n    gpu_rand = torch.rand(2, 2, device='cuda')\n    print(gpu_rand)\nelse:\n    print('Sorry, CPU only.')\n\n\n##########################################################################\n# By default, new tensors are created on the CPU, so we have to specify\n# when we want to create our tensor on the GPU with the optional\n# ``device`` argument. You can see when we print the new tensor, PyTorch\n# informs us which device it’s on (if it’s not on CPU).\n# \n# You can query the number of GPUs with ``torch.cuda.device_count()``. If\n# you have more than one GPU, you can specify them by index:\n# ``device='cuda:0'``, ``device='cuda:1'``, etc.\n# \n# As a coding practice, specifying our devices everywhere with string\n# constants is pretty fragile. In an ideal world, your code would perform\n# robustly whether you’re on CPU or GPU hardware. You can do this by\n# creating a device handle that can be passed to your tensors instead of a\n# string:\n# \n\nif torch.cuda.is_available():\n    my_device = torch.device('cuda')\nelse:\n    my_device = torch.device('cpu')\nprint('Device: {}'.format(my_device))\n\nx = torch.rand(2, 2, device=my_device)\nprint(x)\n\n\n#########################################################################\n# If you have an existing tensor living on one device, you can move it to\n# another with the ``to()`` method. The following line of code creates a\n# tensor on CPU, and moves it to whichever device handle you acquired in\n# the previous cell.\n# \n\ny = torch.rand(2, 2)\ny = y.to(my_device)\n\n\n##########################################################################\n# It is important to know that in order to do computation involving two or\n# more tensors, *all of the tensors must be on the same device*. The\n# following code will throw a runtime error, regardless of whether you\n# have a GPU device available:\n# \n# ::\n# \n#    x = torch.rand(2, 2)\n#    y = torch.rand(2, 2, device='gpu')\n#    z = x + y  # exception will be thrown\n# \n\n\n###########################################################################\n# Manipulating Tensor Shapes\n# --------------------------\n# \n# Sometimes, you’ll need to change the shape of your tensor. Below, we’ll\n# look at a few common cases, and how to handle them.\n# \n# Changing the Number of Dimensions\n# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n# \n# One case where you might need to change the number of dimensions is\n# passing a single instance of input to your model. PyTorch models\n# generally expect *batches* of input.\n# \n# For example, imagine having a model that works on 3 x 226 x 226 images -\n# a 226-pixel square with 3 color channels. When you load and transform\n# it, you’ll get a tensor of shape ``(3, 226, 226)``. Your model, though,\n# is expecting input of shape ``(N, 3, 226, 226)``, where ``N`` is the\n# number of images in the batch. So how do you make a batch of one?\n# \n\na = torch.rand(3, 226, 226)\nb = a.unsqueeze(0)\n\nprint(a.shape)\nprint(b.shape)\n\n\n##########################################################################\n# The ``unsqueeze()`` method adds a dimension of extent 1.\n# ``unsqueeze(0)`` adds it as a new zeroth dimension - now you have a\n# batch of one!\n# \n# So if that’s *un*\\ squeezing? What do we mean by squeezing? We’re taking\n# advantage of the fact that any dimension of extent 1 *does not* change\n# the number of elements in the tensor.\n# \n\nc = torch.rand(1, 1, 1, 1, 1)\nprint(c)\n\n\n##########################################################################\n# Continuing the example above, let’s say the model’s output is a\n# 20-element vector for each input. You would then expect the output to\n# have shape ``(N, 20)``, where ``N`` is the number of instances in the\n# input batch. That means that for our single-input batch, we’ll get an\n# output of shape ``(1, 20)``.\n# \n# What if you want to do some *non-batched* computation with that output -\n# something that’s just expecting a 20-element vector?\n# \n\na = torch.rand(1, 20)\nprint(a.shape)\nprint(a)\n\nb = a.squeeze(0)\nprint(b.shape)\nprint(b)\n\nc = torch.rand(2, 2)\nprint(c.shape)\n\nd = c.squeeze(0)\nprint(d.shape)\n\n\n#########################################################################\n# You can see from the shapes that our 2-dimensional tensor is now\n# 1-dimensional, and if you look closely at the output of the cell above\n# you’ll see that printing ``a`` shows an “extra” set of square brackets\n# ``[]`` due to having an extra dimension.\n# \n# You may only ``squeeze()`` dimensions of extent 1. See above where we\n# try to squeeze a dimension of size 2 in ``c``, and get back the same\n# shape we started with. Calls to ``squeeze()`` and ``unsqueeze()`` can\n# only act on dimensions of extent 1 because to do otherwise would change\n# the number of elements in the tensor.\n# \n# Another place you might use ``unsqueeze()`` is to ease broadcasting.\n# Recall the example above where we had the following code:\n# \n# ::\n# \n#    a =     torch.ones(4, 3, 2)\n# \n#    c = a * torch.rand(   3, 1) # 3rd dim = 1, 2nd dim identical to a\n#    print(c)\n# \n# The net effect of that was to broadcast the operation over dimensions 0\n# and 2, causing the random, 3 x 1 tensor to be multiplied element-wise by\n# every 3-element column in ``a``.\n# \n# What if the random vector had just been 3-element vector? We’d lose the\n# ability to do the broadcast, because the final dimensions would not\n# match up according to the broadcasting rules. ``unsqueeze()`` comes to\n# the rescue:\n# \n\na = torch.ones(4, 3, 2)\nb = torch.rand(   3)     # trying to multiply a * b will give a runtime error\nc = b.unsqueeze(1)       # change to a 2-dimensional tensor, adding new dim at the end\nprint(c.shape)\nprint(a * c)             # broadcasting works again!\n\n\n######################################################################\n# The ``squeeze()`` and ``unsqueeze()`` methods also have in-place\n# versions, ``squeeze_()`` and ``unsqueeze_()``:\n# \n\nbatch_me = torch.rand(3, 226, 226)\nprint(batch_me.shape)\nbatch_me.unsqueeze_(0)\nprint(batch_me.shape)\n\n\n##########################################################################\n# Sometimes you’ll want to change the shape of a tensor more radically,\n# while still preserving the number of elements and their contents. One\n# case where this happens is at the interface between a convolutional\n# layer of a model and a linear layer of the model - this is common in\n# image classification models. A convolution kernel will yield an output\n# tensor of shape *features x width x height,* but the following linear\n# layer expects a 1-dimensional input. ``reshape()`` will do this for you,\n# provided that the dimensions you request yield the same number of\n# elements as the input tensor has:\n# \n\noutput3d = torch.rand(6, 20, 20)\nprint(output3d.shape)\n\ninput1d = output3d.reshape(6 * 20 * 20)\nprint(input1d.shape)\n\n# can also call it as a method on the torch module:\nprint(torch.reshape(output3d, (6 * 20 * 20,)).shape)\n\n\n###############################################################################\n# .. note::\n#      The ``(6 * 20 * 20,)`` argument in the final line of the cell\n#      above is because PyTorch expects a **tuple** when specifying a\n#      tensor shape - but when the shape is the first argument of a method, it\n#      lets us cheat and just use a series of integers. Here, we had to add the\n#      parentheses and comma to convince the method that this is really a\n#      one-element tuple.\n# \n# When it can, ``reshape()`` will return a *view* on the tensor to be\n# changed - that is, a separate tensor object looking at the same\n# underlying region of memory. *This is important:* That means any change\n# made to the source tensor will be reflected in the view on that tensor,\n# unless you ``clone()`` it.\n# \n# There *are* conditions, beyond the scope of this introduction, where\n# ``reshape()`` has to return a tensor carrying a copy of the data. For\n# more information, see the\n# `docs <https://pytorch.org/docs/stable/torch.html#torch.reshape>`__.\n# \n\n\n#######################################################################\n# NumPy Bridge\n# ------------\n# \n# In the section above on broadcasting, it was mentioned that PyTorch’s\n# broadcast semantics are compatible with NumPy’s - but the kinship\n# between PyTorch and NumPy goes even deeper than that.\n# \n# If you have existing ML or scientific code with data stored in NumPy\n# ndarrays, you may wish to express that same data as PyTorch tensors,\n# whether to take advantage of PyTorch’s GPU acceleration, or its\n# efficient abstractions for building ML models. It’s easy to switch\n# between ndarrays and PyTorch tensors:\n# \n\nimport numpy as np\n\nnumpy_array = np.ones((2, 3))\nprint(numpy_array)\n\npytorch_tensor = torch.from_numpy(numpy_array)\nprint(pytorch_tensor)\n\n\n##########################################################################\n# PyTorch creates a tensor of the same shape and containing the same data\n# as the NumPy array, going so far as to keep NumPy’s default 64-bit float\n# data type.\n# \n# The conversion can just as easily go the other way:\n# \n\npytorch_rand = torch.rand(2, 3)\nprint(pytorch_rand)\n\nnumpy_rand = pytorch_rand.numpy()\nprint(numpy_rand)\n\n\n##########################################################################\n# It is important to know that these converted objects are using *the same\n# underlying memory* as their source objects, meaning that changes to one\n# are reflected in the other:\n# \n\nnumpy_array[1, 1] = 23\nprint(pytorch_tensor)\n\npytorch_rand[1, 1] = 17\nprint(numpy_rand)\n", "meta": {"hexsha": "f1674566932d5180c99f5b771f2cbe506d469856", "size": 32138, "ext": "py", "lang": "Python", "max_stars_repo_path": "beginner_source/tensors_deeper_tutorial.py", "max_stars_repo_name": "holly1238/pttutorialtest", "max_stars_repo_head_hexsha": "29f900dac0f21db101295590a4b081c4e42e5471", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "beginner_source/tensors_deeper_tutorial.py", "max_issues_repo_name": "holly1238/pttutorialtest", "max_issues_repo_head_hexsha": "29f900dac0f21db101295590a4b081c4e42e5471", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "beginner_source/tensors_deeper_tutorial.py", "max_forks_repo_name": "holly1238/pttutorialtest", "max_forks_repo_head_hexsha": "29f900dac0f21db101295590a4b081c4e42e5471", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.7584033613, "max_line_length": 197, "alphanum_fraction": 0.6356027133, "include": true, "reason": "import numpy", "num_tokens": 8080, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.1294027399852894, "lm_q1q2_score": 0.0647013699926447}}
{"text": "# ---\n# Copyright 2021 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# jupyter:\n#   jupytext:\n#     formats: ipynb,md:myst,py\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.5'\n#       jupytext_version: 1.10.0\n#   kernelspec:\n#     display_name: Python 3\n#     name: python3\n# ---\n\n# # Autodidax: JAX core from scratch\n#\n# Ever want to learn how JAX works, but the implementation seemed too\n# impenetrable? Well, you're in luck! By reading this tutorial, you'll learn\n# every big idea in JAX's core system. You'll even get clued into our weird\n# jargon!\n\n# ## Part 1: Transformations as interpreters: standard evaluation, `jvp`, and `vmap`\n#\n# We want to transform functions that look like this:\n#\n# ```python\n# def f(x):\n#   y = sin(x) * 2\n#   z = - y + x\n#   return z\n# ```\n#\n# Think of functions like `sin` and the arithmetic operations underlying the\n# infix operators (`mul`, `add`, and `neg`) as primitive operations, meaning\n# atomic units of processing rather than compositions.\n#\n# \"Transform\" means \"interpret differently.\" Instead of standard interpretation\n# where we apply primitive functions to numerical inputs to produce numerical\n# outputs, we want to override primitive application and let different values\n# flow through our program. For example, we might want to replace the\n# application of every primitive with an application of [its JVP\n# rule](https://jax.readthedocs.io/en/latest/notebooks/autodiff_cookbook.html),\n# and let primal-tangent pairs flow through our program. Moreover, we want to\n# apply a composition of multiple transformations, leading to stacks of\n# interpreters.\n\n# ### JAX core machinery\n#\n# We can implement stacks of interpreters and even have them all discharge on\n# the fly as we execute the Python function to be transformed. To start, let's\n# define these primitives so that we can intercept their application:\n\n\n# +\nfrom typing import NamedTuple\n\nclass Primitive(NamedTuple):\n  name: str\n\nadd_p = Primitive('add')\nmul_p = Primitive('mul')\nneg_p = Primitive(\"neg\")\nsin_p = Primitive(\"sin\")\ncos_p = Primitive(\"cos\")\nreduce_sum_p = Primitive(\"reduce_sum\")\ngreater_p = Primitive(\"greater\")\n\ndef add(x, y): return bind(add_p, x, y)\ndef mul(x, y): return bind(mul_p, x, y)\ndef neg(x): return bind(neg_p, x)\ndef sin(x): return bind(sin_p, x)\ndef cos(x): return bind(cos_p, x)\ndef reduce_sum(x, axis=None): return bind(reduce_sum_p, x, axis=axis)\ndef greater(x, y): return bind(greater_p, x, y)\n\n\n# -\n\n# We'll set up array data types and infix operator methods in a moment.\n#\n# A `Primitive` is just an object with a name, to which we attach our\n# interpretation rules (one for each transformation). The `bind` function is our\n# interception point: it'll figure out which transformation rule to apply, based\n# on how the arguments are boxed in tracers and what interpreters are active.\n#\n# The functions that user code calls, like `add` and `sin`, are just wrappers\n# around calls to `bind`. These wrappers let us control how arguments are passed\n# to `bind`, and in particular we follow a handy internal convention: when we\n# call `bind`, we pass values representing array data as positional arguments,\n# and we pass metadata like the `axis` argument to `sum_p` via keyword. This\n# calling convention simplifies some core logic (since e.g. instances of the\n# `Tracer` class to be defined below can only occurr in positional arguments to\n# `bind`). The wrappers can also provide docstrings!\n#\n# We represent active interpreters as a stack. The stack is just a simple\n# `list`, and each element is a container with an integer level (corresponding\n# to the element's height in the stack), an interpreter type (which we'll call a\n# `trace_type`), and an optional field for any global data the interpreter\n# needs. We call each element a `MainTrace`, though maybe \"Interpreter\" would be\n# more descriptive.\n\n# +\nfrom contextlib import contextmanager\nfrom typing import Type, List, Optional, Any\n\nclass MainTrace(NamedTuple):\n  level: int\n  trace_type: Type['Trace']\n  global_data: Optional[Any]\n\ntrace_stack: List[MainTrace] = []\n\n@contextmanager\ndef new_main(trace_type: Type['Trace'], global_data=None):\n  level = len(trace_stack)\n  main = MainTrace(level, trace_type, global_data)\n  trace_stack.append(main)\n\n  try:\n    yield main\n  finally:\n    trace_stack.pop()\n\n\n# -\n\n# When we're about to apply a transformed function, we'll push another\n# interpreter onto the stack using `new_main`. Then, as we apply primitives in\n# the function, we can think of the `bind` first being interpreted by the trace\n# at the top of the stack (i.e. with the highest level). If that first\n# interpreter itself binds other primitives in its interpretation rule for the\n# primitive, like how the JVP rule of `sin_p` might bind `cos_p` and `mul_p`,\n# then those `bind` calls will be handled by the interpreter at the next level\n# down.\n#\n# What goes at the bottom of the interpreter stack? At the bottom, we know all\n# the transformation interpreters are finished, and we just want to do standard\n# evaluation. So at the bottom we'll put an evaluation interpreter.\n#\n# Let's sketch out the interface for interpreters, which is based on the `Trace`\n# and `Tracer` base classes. A `Tracer` represents a boxed-up value, perhaps\n# carrying some extra context data used by the interpreter. A `Trace` handles\n# boxing up vales into `Tracers` and also handles primitive application.\n\nclass Trace:\n  main: MainTrace\n\n  def __init__(self, main: MainTrace) -> None:\n    self.main = main\n\n  def pure(self, val): assert False  # must override\n  def lift(self, val): assert False  # must override\n\n  def process_primitive(self, primitive, tracers, params):\n    assert False  # must override\n\n\n# The first two methods are about boxing up values in `Tracer`s, which are the\n# objects that flow through the Python programs we transform. The last method is\n# the callback we'll use to interpret primitive application.\n#\n# The `Trace` itself doesn't contain any data, other than a reference to its\n# corresponding `MainTrace` instance. In fact, multiple instances of a `Trace`\n# might be created and discarded during an application of a transformation,\n# whereas only a single `MainTrace` instance is created per application of a\n# transformation.\n#\n# As for `Tracer`s themselves, each one carries an abstract value (and forwards\n# infix operators to it), and the rest is up to the transformation. (The\n# relationship between `Tracer`s and `AbstractValue`s is that there's one\n# `Tracer` per transformation, and at least one `AbstractValue` per base type,\n# like arrays.)\n\n# +\nimport numpy as np\nfrom typing import Tuple\n\nclass Tracer:\n  _trace: Trace\n\n  __array_priority__ = 1000\n\n  @property\n  def aval(self):\n    assert False  # must override\n\n  def full_lower(self):\n    return self  # default implementation\n\n  def __neg__(self): return self.aval._neg(self)\n  def __add__(self, other): return self.aval._add(self, other)\n  def __radd__(self, other): return self.aval._radd(self, other)\n  def __mul__(self, other): return self.aval._mul(self, other)\n  def __rmul__(self, other): return self.aval._rmul(self, other)\n  def __gt__(self, other): return self.aval._gt(self, other)\n  def __bool__(self): return self.aval._bool(self)\n  def __nonzero__(self): return self.aval._nonzero(self)\n\n  def __getattr__(self, name):\n    try:\n      return getattr(self.aval, name)\n    except AttributeError:\n      raise AttributeError(f\"{self.__class__.__name__} has no attribute {name}\")\n\nclass ShapedArray:\n  array_abstraction_level = 1\n  shape: Tuple[int]\n  dtype: np.dtype\n\n  def __init__(self, shape, dtype):\n    self.shape = shape\n    self.dtype = dtype\n\n  @property\n  def ndim(self):\n    return len(self.shape)\n\n  _neg = staticmethod(neg)\n  _add = staticmethod(add)\n  _radd = staticmethod(add)\n  _mul = staticmethod(mul)\n  _rmul = staticmethod(mul)\n  _gt = staticmethod(greater)\n\n  @staticmethod\n  def _bool(tracer):\n    raise Exception(\"ShapedArray can't be unambiguously converted to bool\")\n\n  @staticmethod\n  def _nonzero(tracer):\n    raise Exception(\"ShapedArray can't be unambiguously converted to bool\")\n\n  def str_short(self):\n    return f'{self.dtype.name}[{\",\".join(str(d) for d in self.shape)}]'\n\nclass ConcreteArray(ShapedArray):\n  array_abstraction_level = 2\n  val: np.ndarray\n\n  def __init__(self, val):\n    self.val = val\n    self.shape = val.shape\n    self.dtype = val.dtype\n\n  @staticmethod\n  def _bool(tracer):\n    return bool(tracer.aval.val)\n\n  @staticmethod\n  def _nonzero(tracer):\n    return bool(tracer.aval.val)\n\ndef get_aval(x):\n  if isinstance(x, Tracer):\n    return x.aval\n  else:\n    return ConcreteArray(np.asarray(x))\n\n\n# -\n\n# Notice that we actually have two `AbstractValue`s for arrays, representing\n# different levels of abstraction. A `ShapedArray` represents the set of all\n# possible arrays with a given shape and dtype. A `ConcreteArray` represents a\n# singleton set consisting of a single array value.\n#\n# Now that we've set up the trace stack, the Trace/Tracer API for interpreters,\n# and abstract values, we can come back to implement `bind`:\n\ndef bind(prim, *args, **params):\n  top_trace = find_top_trace(args)\n  tracers = [full_raise(top_trace, arg) for arg in args]\n  out = top_trace.process_primitive(prim, tracers, params)\n  return full_lower(out)\n\n\n# The main action is that we call `find_top_trace` to figure out which\n# interpreter should handle this primitive application as a function of the\n# arguments and the active traces on the trace stack. We then call that top\n# trace's `process_primitive` so that the trace can apply its interpretation\n# rule. The calls to `full_raise` just ensure that the inputs are boxed in the\n# top trace's `Tracer` instances, and the call to `full_lower` is an optional\n# optimization so that we unbox values out of `Tracer`s as much as possible.\n\n# +\nfrom operator import attrgetter\n\ndef find_top_trace(xs) -> Trace:\n  top_main = max((x._trace.main for x in xs if isinstance(x, Tracer)),\n                 default=trace_stack[0], key=attrgetter('level'))\n  return top_main.trace_type(top_main)\n\n\n# -\n\n# In words, `find_top_trace` returns the highest-level interpreter associated\n# with the `Tracer`s on its inputs, and otherwise returns the interpreter at the\n# bottom of the stack (which is always an evaluation trace, at least for now).\n# This corresponds to JAX transformations mostly working by data dependence\n# _except_ for the special bottom-of-the-stack interpreter, which interprets\n# everything.\n\n# +\ndef full_lower(val):\n  if isinstance(val, Tracer):\n    return val.full_lower()\n  else:\n    return val\n\ndef full_raise(trace, val) -> Tracer:\n  if not isinstance(val, Tracer):\n    return trace.pure(val)\n  level = trace.main.level\n  if val._trace.main is trace.main:\n    return val\n  elif val._trace.main.level < level:\n    return trace.lift(val)\n  elif val._trace.main.level > level:\n    raise Exception(f\"Can't lift level {val._trace.main.level} to {level}.\")\n  else:  # val._trace.level == level\n    raise Exception(f\"Different traces at same level: {val._trace}, {trace}.\")\n\n\n# -\n\n# The logic in `full_raise` serves to box values into `Tracer`s for a particular\n# `Trace`, calling different methods on the `Trace` based on context:\n# `Trace.pure` is called on non-`Tracer` constants, and `Trace.lift` is called\n# for values that are already `Tracer`s from a lower-level interpreter. These\n# two methods could share the same implementation, but by distinguishing them in\n# the core logic we can provide more information to the `Trace` subclass.\n#\n# That's it for the JAX core! Now we can start adding interpreters.\n\n# ### Evaluation interpreter\n#\n# We'll start with the simplest interpreter: the evaluation interpreter that\n# will sit at the bottom of the interpreter stack.\n\n# +\nclass EvalTrace(Trace):\n  pure = lift = lambda self, x: x  # no boxing in Tracers needed\n\n  def process_primitive(self, primitive, tracers, params):\n    return impl_rules[primitive](*tracers, **params)\n\ntrace_stack.append(MainTrace(0, EvalTrace, None))  # special bottom of the stack\n\nimpl_rules = {}\nimpl_rules[add_p] = np.add\nimpl_rules[mul_p] = np.multiply\nimpl_rules[neg_p] = np.negative\nimpl_rules[sin_p] = np.sin\nimpl_rules[cos_p] = np.cos\nimpl_rules[reduce_sum_p] = np.sum\nimpl_rules[greater_p] = np.greater\n\n\n# -\n\n# With this interpreter, we can evaluate user functions:\n\n# +\ndef f(x):\n  y = sin(x) * 2\n  z = - y + x\n  return z\n\nprint(f(3.0))\n\n\n# -\n\n# Woo! Like going around in a big circle. But the point of this indirection is\n# that now we can add some real transformations.\n\n# ### Forward-mode autodiff with `jvp`\n#\n# First, a couple of helper functions:\n\n# +\ndef zeros_like(val):\n  return np.zeros_like(val)\n\ndef unzip2(pairs):\n  lst1, lst2 = [], []\n  for x1, x2 in pairs:\n    lst1.append(x1)\n    lst2.append(x2)\n  return lst1, lst2\n\n\n# -\n\n# The `Tracer` for forward-mode autodiff carries a primal-tangent pair. The\n# `Trace` applies JVP rules.\n\n# +\nclass JVPTracer(Tracer):\n  def __init__(self, trace, primal, tangent):\n    self._trace = trace\n    self.primal = primal\n    self.tangent = tangent\n\n  @property\n  def aval(self):\n    return get_aval(self.primal)\n\nclass JVPTrace(Trace):\n  pure = lift = lambda self, val: JVPTracer(self, val, zeros_like(val))\n\n  def process_primitive(self, primitive, tracers, params):\n    primals_in, tangents_in = unzip2((t.primal, t.tangent) for t in tracers)\n    jvp_rule = jvp_rules[primitive]\n    primal_out, tangent_out = jvp_rule(primals_in, tangents_in, **params)\n    return JVPTracer(self, primal_out, tangent_out)\n\njvp_rules = {}\n\n\n# -\n\n# Notice both `lift` and `sublift` package a value into a `JVPTracer` with the\n# minimal amount of context, which is a zero tangent value.\n\n# Let's add some JVP rules for primitives:\n\n# +\ndef add_jvp(primals, tangents):\n  (x, y), (x_dot, y_dot) = primals, tangents\n  return x + y, x_dot + y_dot\njvp_rules[add_p] = add_jvp\n\ndef mul_jvp(primals, tangents):\n  (x, y), (x_dot, y_dot) = primals, tangents\n  return x * y, x_dot * y + x * y_dot\njvp_rules[mul_p] = mul_jvp\n\ndef sin_jvp(primals, tangents):\n  (x,), (x_dot,) = primals, tangents\n  return sin(x), cos(x) * x_dot\njvp_rules[sin_p] = sin_jvp\n\ndef cos_jvp(primals, tangents):\n  (x,), (x_dot,) = primals, tangents\n  return cos(x), -sin(x) * x_dot\njvp_rules[cos_p] = cos_jvp\n\ndef neg_jvp(primals, tangents):\n  (x,), (x_dot,) = primals, tangents\n  return neg(x), neg(x_dot)\njvp_rules[neg_p] = neg_jvp\n\ndef reduce_sum_jvp(primals, tangents, *, axis):\n  (x,), (x_dot,) = primals, tangents\n  return reduce_sum(x, axis), reduce_sum(x_dot, axis)\njvp_rules[reduce_sum_p] = reduce_sum_jvp\n\ndef greater_jvp(primals, tangents):\n  (x, y), _ = primals, tangents\n  out_primal = greater(x, y)\n  return out_primal, zeros_like(out_primal)\njvp_rules[greater_p] = greater_jvp\n\n\n# -\n\n# Finally, we add a transformation API to kick off the trace:\n\ndef jvp(f, primals, tangents):\n  with new_main(JVPTrace) as main:\n    trace = JVPTrace(main)\n    tracers_in = [JVPTracer(trace, x, t) for x, t in zip(primals, tangents)]\n    out = f(*tracers_in)\n    tracer_out = full_raise(trace, out)\n    primal_out, tangent_out = tracer_out.primal, tracer_out.tangent\n  return primal_out, tangent_out\n\n\n# And with that, we can differentiate!\n\nx = 3.0\ny, sin_deriv_at_3 = jvp(sin, (x,), (1.0,))\nprint(sin_deriv_at_3)\nprint(cos(3.0))\n\n\n# +\ndef f(x):\n  y = sin(x) * 2\n  z = - y + x\n  return z\n\nx, xdot = 3., 1.\ny, ydot = jvp(f, (x,), (xdot,))\nprint(y)\nprint(ydot)\n\n\n# +\ndef deriv(f):\n  return lambda x: jvp(f, (x,), (1.,))[1]\n\nprint(deriv(sin)(3.))\nprint(deriv(deriv(sin))(3.))\nprint(deriv(deriv(deriv(sin)))(3.))\nprint(deriv(deriv(deriv(deriv(sin))))(3.))\n\n\n# +\ndef f(x):\n  if x > 0.:  # Python control flow\n    return 2. * x\n  else:\n    return x\n\nprint(deriv(f)(3.))\nprint(deriv(f)(-3.))\n\n\n# -\n\n# ### Vectorized batching with `vmap`\n#\n# First, a couple helper functions, one for producing mapped abstract values\n# from unmapped ones (by removing an axis), and one for moving batch dimensions\n# around:\n\n# +\ndef mapped_aval(batch_dim, aval):\n  shape = list(aval.shape)\n  del shape[batch_dim]\n  return ShapedArray(tuple(shape), aval.dtype)\n\ndef move_batch_axis(axis_size, src, dst, x):\n  if src is not_mapped:\n    target_shape = list(np.shape(x))\n    target_shape.insert(dst, axis_size)\n    return np.broadcast_to(np.expand_dims(x, dst), target_shape)\n  else:\n    return np.moveaxis(x, src, dst)\n\n\n# -\n\n# The `Tracer` for vectorized batching carries a batched value and an optional\n# integer indicating which axis (if any) is the batch axis.\n\n# +\nfrom typing import Union\n\nclass NotMapped: pass\nnot_mapped = NotMapped()\n\nclass BatchTracer(Tracer):\n  def __init__(self, trace, val, batch_dim: Union[NotMapped, int]):\n    self._trace = trace\n    self.val = val\n    self.batch_dim = batch_dim\n\n  @property\n  def aval(self):\n    if self.batch_dim is not_mapped:\n      return get_aval(self.val)\n    else:\n      return mapped_aval(self.batch_dim, get_aval(self.val))\n\n  def full_lower(self):\n    if self.batch_dim is not_mapped:\n      return full_lower(self.val)\n    else:\n      return self\n\nclass BatchTrace(Trace):\n  pure = lift = lambda self, val: BatchTracer(self, val, not_mapped)\n\n  def process_primitive(self, primitive, tracers, params):\n    vals_in, bdims_in = unzip2((t.val, t.batch_dim) for t in tracers)\n    vmap_rule = vmap_rules[primitive]\n    val_out, bdim_out = vmap_rule(self.axis_size, vals_in, bdims_in, **params)\n    return BatchTracer(self, val_out, bdim_out)\n\n  @property\n  def axis_size(self):\n    return self.main.global_data\n\nvmap_rules = {}\n# -\n\n# Here we've implemented the optional `Tracer.full_lower` method, which lets us\n# peel off a batching tracer if it's not needed because it doesn't represent a\n# batched value.\n#\n# For `BatchTrace`, analogous to `JVPTrace`, the methods `pure` and `lift` just\n# box a value in a `BatchTracer` with the minimal amount of context, which in\n# this case is a `batch_dim` taking the sentinel value `not_mapped`. Notice we\n# use the `MainTrace`'s interpreter-global data field to store the batch axis\n# size.\n#\n# Next we can define batching interpreter rules for each primitive:\n\n# +\nfrom functools import partial\n\ndef broadcasting_binop_batching_rule(op, axis_size, vals_in, dims_in):\n  (x, y), (x_bdim, y_bdim) = vals_in, dims_in\n  if x_bdim != y_bdim:\n    y = move_batch_axis(axis_size, y_bdim, x_bdim, y)\n  return op(x, y), x_bdim\nvmap_rules[add_p] = partial(broadcasting_binop_batching_rule, add)\nvmap_rules[mul_p] = partial(broadcasting_binop_batching_rule, mul)\n\ndef vectorized_unop_batching_rule(op, axis_size, vals_in, dims_in):\n  (x,), (x_bdim,) = vals_in, dims_in\n  return op(x), x_bdim\nvmap_rules[sin_p] = partial(vectorized_unop_batching_rule, sin)\nvmap_rules[cos_p] = partial(vectorized_unop_batching_rule, cos)\nvmap_rules[neg_p] = partial(vectorized_unop_batching_rule, neg)\n\ndef reduce_sum_batching_rule(axis_size, vals_in, dims_in, *, axis):\n  (x,), (x_bdim,) = vals_in, dims_in\n  new_axis = axis + (x_bdim <= axis)\n  out_bdim = x_bdim - (new_axis < x_bdim)\n  return reduce_sum(x, new_axis), out_bdim\nvmap_rules[reduce_sum_p] = reduce_sum_batching_rule\n\n\n# -\n\n# Finally, we add a transformation API to kick off the trace:\n\ndef vmap(f, in_axes, out_axis):\n  def batched_f(*args):\n    axis_size, = {x.shape[ax] for x, ax in zip(args, in_axes)\n                  if ax is not None}\n    with new_main(BatchTrace, axis_size) as main:\n      trace = BatchTrace(main)\n      tracers_in = [BatchTracer(trace, x, ax) if ax is not None else x\n                    for x, ax in zip(args, in_axes)]\n      out = f(*tracers_in)\n      tracer_out = full_raise(trace, out)\n      val_out, batch_dim_out = tracer_out.val, tracer_out.batch_dim\n    return move_batch_axis(axis_size, batch_dim_out, out_axis, val_out)\n  return batched_f\n\n\n# +\ndef add_one_to_a_scalar(scalar):\n  assert np.ndim(scalar) == 0\n  return 1 + scalar\n\nvector_in = np.arange(3.)\nvector_out = vmap(add_one_to_a_scalar, (0,), 0)(vector_in)\n\nprint(vector_in)\nprint(vector_out)\n\n\n# +\ndef jacfwd(f, x):\n  pushfwd = lambda v: jvp(f, (x,), (v,))[1]\n  vecs_in = np.eye(np.size(x)).reshape(np.shape(x) * 2)\n  return vmap(pushfwd, (0,), 0)(vecs_in)\n\ndef f(x):\n  return sin(x)\n\njacfwd(f, np.arange(3.))\n# -\n\n# That's it for `jvp` and `vmap`! Before moving on, let's highlight a few\n# simplifications in what we've seen so far compared to the full JAX\n# implementation:\n# 1. **Fewer, simpler primitives.** More primitives means more interpretation\n# rules, and for more complex primitives (like for convolution or advanced\n# indexing) each rule is harder to write. But the overarching design is no\n# different.\n# 1. **Transformations expect arrays in, single array out.**\n# 2. **No symbolic zeros in autodiff.**\n# 3. **No special call primitives yet.** The core machinery needs to be\n#     generalized to handle the most flexible kind of higher-order primitive,\n#     used by `jax.custom_jvp` and `jax.custom_vjp`.\n\n# ## Part 2: Jaxprs, for `jit` and `vjp`\n#\n# The next transformations are the horizon are `jit` for just-in-time\n# compilation and `vjp` for reverse-mode autodiff.  (`grad` is just a small\n# wrapper around `vjp`.) For `jvp` and `vmap` we only needed each `Tracer` to\n# carry a little    bit of extra context, but for both `jit` and `vjp` we need\n# much richer context: we need to represent _programs_. That is, we need jaxprs!\n#\n# Jaxprs are JAX's internal intermediate representation of programs. Jaxprs are\n# an explicitly typed, functional, first-order language. We need a program\n# representation for `jit` because the purpose of `jit` is to stage computation\n# out of Python. For any computation we want to stage out, we need to be able to\n# represent it as data, and build it up as we trace a Python function.\n# Similarly, `vjp` needs a way to represent the computation for the backward\n# pass of reverse-mode autodiff. We use the same jaxpr program representation\n# for both needs.\n#\n# (Building a program representation is the most\n# [free](https://en.wikipedia.org/wiki/Free_object) kind of\n# trace- transformation, and so except for issues around handling native Python\n# control flow, any transformation could be implemented by first tracing to a\n# jaxpr and then interpreting the jaxpr.)\n#\n# The jaxpr term syntax is roughly:\n#\n# ```\n# jaxpr ::=\n#   { lambda <binder> , ... .\n#     let <eqn>\n#         ...\n#     in <atom> }\n#\n# binder ::= <var>:<array_type>\n# var ::= a | b | c | ...\n# atom ::= <var> | <literal>\n# literal ::= <int32> | <float32>\n#\n# eqn ::= <binder> = <primitive> [ <params> ] <atom> , ...\n# ```\n#\n# The syntax of types is:\n#\n# ```\n# jaxpr_type ::= [<array_type>, ...] -> [<array_type>, ...]\n# array_type ::= <dtype>[<shape>]\n# dtype ::= f32 | f64 | i32 | i64\n# shape ::= <int> , ...\n# ```\n#\n# How do we represent these as Python data structures? We reuse ShapedArrays to\n# represent types, and we can represent the term syntax with a few Python\n# structs:\n\n# +\nfrom typing import Dict, Set\n\nclass Var:\n  aval: ShapedArray\n  def __init__(self, aval): self.aval = aval\n\nclass Lit:\n  val: Any\n  aval: ShapedArray\n\n  def __init__(self, val):\n    self.val = val\n    self.aval = raise_to_shaped(get_aval(self.val))\n\nAtom = Union[Var, Lit]\n\nclass JaxprEqn(NamedTuple):\n  primitive: Primitive\n  inputs: List[Atom]\n  params: Dict[str, Any]\n  out_binder: Var\n\nclass Jaxpr(NamedTuple):\n  in_binders: List[Var]\n  eqns: List[JaxprEqn]\n  out: Atom\n\n\ndef raise_to_shaped(aval):\n  return ShapedArray(aval.shape, aval.dtype)\n\n\n# +\nclass JaxprType:\n  in_types: List[ShapedArray]\n  out_type: ShapedArray\n\n  def __init__(self, in_types, out_type):\n    self.in_types = in_types\n    self.out_type = out_type\n\n  def __repr__(self):\n    in_types = ', '.join(aval.str_short() for aval in self.in_types)\n    out_type = self.out_type.str_short()\n    return f'({in_types}) -> {out_type}'\n\n\ndef typecheck_jaxpr(jaxpr: Jaxpr) -> JaxprType:\n  env: Set[Var] = set()\n\n  for v in jaxpr.in_binders:\n    env.add(v)\n\n  for eqn in jaxpr.eqns:\n    in_types = [typecheck_atom(env, x) for x in eqn.inputs]\n    out_type = abstract_eval_rules[eqn.primitive](*in_types, **eqn.params)\n    if not types_equal(out_type, eqn.out_binder.aval): raise TypeError\n    env.add(eqn.out_binder)\n\n  out_type = typecheck_atom(env, jaxpr.out)\n  return JaxprType([v.aval for v in jaxpr.in_binders], out_type)\n\ndef typecheck_atom(env: Set[Var], x: Atom) -> ShapedArray:\n  if isinstance(x, Var):\n    if x not in env: raise TypeError(\"unbound variable\")\n    return x.aval\n  elif isinstance(x, Lit):\n    return raise_to_shaped(get_aval(x.val))\n  else:\n    assert False\n\ndef types_equal(a: ShapedArray, b: ShapedArray) -> bool:\n  return a.shape == b.shape and a.dtype == b.dtype\n\n\n# -\n\n# Now that we have jaxprs as a data structure, we need ways to produce these\n# from tracing Python code. In general there are two variants of how we trace to\n# a jaxpr; `jit` uses one and `vjp` uses the other. We'll start with the one\n# used   by `jit`, which is also used by control flow primitives like\n# `lax.cond`, `lax.while_loop`, and `lax.scan`.\n\n# +\n# NB: the analogous class in JAX is called 'DynamicJaxprTracer'\nclass JaxprTracer(Tracer):\n  __slots__ = ['aval']\n  aval: ShapedArray\n\n  def __init__(self, trace, aval):\n    self._trace = trace\n    self.aval = aval\n\n# NB: the analogous class in JAX is called 'DynamicJaxprTrace'\nclass JaxprTrace(Trace):\n  def new_arg(self, aval: ShapedArray) -> JaxprTracer:\n    aval = raise_to_shaped(aval)\n    tracer = JaxprTracer(self, aval)\n    self.builder.tracer_to_var[id(tracer)] = Var(aval)\n    return tracer\n\n  def get_or_make_const_tracer(self, val: Any) -> JaxprTracer:\n    tracer = self.builder.const_tracers.get(id(val))\n    if tracer is None:\n      tracer = JaxprTracer(self, raise_to_shaped(get_aval(val)))\n      self.builder.add_const(tracer, val)\n    return tracer\n  pure = lift = get_or_make_const_tracer\n\n  def process_primitive(self, primitive, tracers, params):\n    avals_in = [t.aval for t in tracers]\n    aval_out = abstract_eval_rules[primitive](*avals_in, **params)\n    out_tracer = JaxprTracer(self, aval_out)\n    inputs = [self.builder.getvar(t) for t in tracers]\n    outvar = self.builder.add_var(out_tracer)\n    self.builder.add_eqn(JaxprEqn(primitive, inputs, params, outvar))\n    return out_tracer\n\n  @property\n  def builder(self):\n    return self.main.global_data\n\n# NB: in JAX, instead of a dict we attach impl rules to the Primitive instance\nabstract_eval_rules = {}\n\n\n# -\n\n# Notice that we keep as interpreter-global data a builder object, which keeps\n# track of variables, constants, and eqns  as we build up the jaxpr.\n\nclass JaxprBuilder:\n  eqns: List[JaxprEqn]\n  tracer_to_var: Dict[int, Var]\n  const_tracers: Dict[int, JaxprTracer]\n  constvals: Dict[Var, Any]\n\n  def __init__(self):\n    self.eqns = []\n    self.tracer_to_var = {}\n    self.const_tracers = {}\n    self.constvals = {}\n\n  def add_eqn(self, eqn: JaxprEqn) -> None:\n    self.eqns.append(eqn)\n\n  def add_var(self, tracer: JaxprTracer) -> Var:\n    var = self.tracer_to_var.get(id(tracer))\n    assert var is None\n    var = self.tracer_to_var[id(tracer)] = Var(tracer.aval)\n    return var\n\n  def getvar(self, tracer: JaxprTracer) -> Var:\n    var = self.tracer_to_var.get(id(tracer))\n    assert var is not None\n    return var\n\n  def add_const(self, tracer: JaxprTracer, val: Any) -> Var:\n    var = self.add_var(tracer)\n    self.const_tracers[id(val)] = tracer\n    self.constvals[var] = val\n    return var\n\n  def build(self, in_tracers: List[JaxprTracer], out_tracer: JaxprTracer\n            ) -> Tuple[Jaxpr, List[Any]]:\n    constvars, constvals = unzip2(self.constvals.items())\n    t2v = lambda t: self.tracer_to_var[id(t)]\n    in_binders = constvars + [t2v(t) for t in in_tracers]\n    jaxpr = Jaxpr(in_binders, self.eqns, t2v(out_tracer))\n    typecheck_jaxpr(jaxpr)\n    return jaxpr, constvals\n\n\n# The rules we need for `JaxprTrace.process_primitive` are essentially typing\n# rules for primitive applications: given   the primitive, its parameters, and\n# types for the inputs, the rule must produce a type for the output, which is\n# then   packaged with the output `JaxprTracer`. We can use abstract evaluation\n# rules for this same purpose, even though they  can be more general (since\n# abstract evaluation rules need to work on ConcreteArray inputs as well). We'll\n# reuse these abstract evaluation rules for the other jaxpr-producing trace\n# machinery, where the potential extra generality is useful.\n\ndef broadcast_shapes(*shapes):\n  assert len(shapes) > 1\n  for sizes in zip(*shapes):\n    sizes = [d for d in sizes if d != 1]\n    if sizes[:-1] != sizes[1:]:\n      raise Exception\n  return tuple(next((d for d in sizes if d != 1), 1) for sizes in zip(*shapes))\n\n\n# +\ndef broadcasting_binop_abstract_eval_rule(*avals_in):\n  out_dtype = np.result_type(*map(np.result_type, avals_in))\n  out_shape = broadcast_shapes(*map(np.shape, avals_in))\n  return ShapedArray(out_shape, out_dtype)\n\nabstract_eval_rules[add_p] = broadcasting_binop_abstract_eval_rule\nabstract_eval_rules[mul_p] = broadcasting_binop_abstract_eval_rule\n\ndef vectorized_unop_abstract_eval_rule(aval_in):\n  return ShapedArray(np.shape(aval_in), np.result_type(aval_in))\n\nabstract_eval_rules[sin_p] = vectorized_unop_abstract_eval_rule\nabstract_eval_rules[cos_p] = vectorized_unop_abstract_eval_rule\nabstract_eval_rules[neg_p] = vectorized_unop_abstract_eval_rule\n\ndef reduce_sum_abstract_eval_rule(aval_in, *, axis):\n  new_shape = [d for i, d in enumerate(aval_in.shape) if i != axis]\n  return ShapedArray(tuple(new_shape), aval_in.dtype)\nabstract_eval_rules[reduce_sum_p] = reduce_sum_abstract_eval_rule\n\n\n# -\n\n# To check our implementation, we can add a `make_jaxpr` transformation and\n# first pretty-printer:\n\ndef make_jaxpr(f, avals_in):\n  builder = JaxprBuilder()\n  with new_main(JaxprTrace, builder) as main:\n    trace = JaxprTrace(main)\n    tracers_in = [trace.new_arg(aval) for aval in avals_in]\n    out = f(*tracers_in)\n    tracer_out = full_raise(trace, out)\n    return builder.build(tracers_in, tracer_out)\n\n# +\nfrom collections import defaultdict\nimport itertools as it\nimport string\n\nclass PPrint:\n  lines: List[Tuple[int, str]]\n\n  def __init__(self, lines):\n    self.lines = lines\n\n  def indent(self, indent: int) -> 'PPrint':\n    return PPrint([(indent + orig_indent, s) for orig_indent, s in self.lines])\n\n  def __add__(self, rhs: 'PPrint') -> 'PPrint':\n    return PPrint(self.lines + rhs.lines)\n\n  def __rshift__(self, rhs: 'PPrint') -> 'PPrint':\n    if not rhs.lines: return self\n    if not self.lines: return rhs\n    indent, s = self.lines[-1]\n    indented_block = rhs.indent(indent + len(s))\n    common_line = s + ' ' * rhs.lines[0][0] + rhs.lines[0][1]\n    return PPrint(self.lines[:-1]\n                  + [(indent, common_line)]\n                  + indented_block.lines[1:])\n\n  def __str__(self) -> str:\n    return '\\n'.join(' ' * indent + s for indent, s in self.lines)\n\ndef pp(s: Any) -> PPrint:\n  return PPrint([(0, line) for line in str(s).splitlines()])\n\ndef vcat(ps: List[PPrint]) -> PPrint:\n  return sum(ps, pp(''))\n\ndef pp_jaxpr(jaxpr: Jaxpr):\n  namegen = (''.join(s) for r in it.count(1)\n             for s in it.permutations(string.ascii_lowercase, r))\n  names = defaultdict(lambda: next(namegen))\n  in_binders = ', '.join(var_str(names, x) for x in jaxpr.in_binders)\n  eqns = vcat([pp_eqn(names, e) for e in jaxpr.eqns])\n  out = names[jaxpr.out] if isinstance(jaxpr.out, Var) else str(jaxpr.out.val)\n  return (pp(f'{{ lambda {in_binders} .') +\n          ((pp('let ') >> eqns) + pp(f'in {out} }}')).indent(2))\n\ndef var_str(names: Dict[Var, str], v: Var) -> str:\n  return f'{names[v]}:{v.aval.str_short()}'\n\ndef pp_eqn(names: Dict[Var, str], eqn: JaxprEqn) -> PPrint:\n  lhs = pp(var_str(names, eqn.out_binder))\n  rhs = (pp(eqn.primitive.name) >> pp_params(eqn.params) >>\n         pp(' '.join(names[x] if isinstance(x, Var) else str(x.val)\n                     for x in eqn.inputs)))\n  return lhs >> pp(' = ') >> rhs\n\ndef pp_params(params: Dict[str, Any]) -> PPrint:\n  items = sorted(params.items())\n  if items:\n    return pp(' [ ') >> vcat([pp(f'{k}={v}') for k, v in items]) >> pp(' ] ')\n  else:\n    return pp(' ')\n\n\n# -\n\njaxpr, consts = make_jaxpr(lambda x: 2. * x, [raise_to_shaped(get_aval(3.))])\nprint(pp_jaxpr(jaxpr))\nprint(typecheck_jaxpr(jaxpr))\n", "meta": {"hexsha": "678db30c92f41d6196ea9304a7d5c0a42c48b6af", "size": 32812, "ext": "py", "lang": "Python", "max_stars_repo_path": "docs/autodidax.py", "max_stars_repo_name": "mtsokol/jax", "max_stars_repo_head_hexsha": "2fc2ff409a5fc3712d42b3cd4c3bb86dff28948a", "max_stars_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "docs/autodidax.py", "max_issues_repo_name": "mtsokol/jax", "max_issues_repo_head_hexsha": "2fc2ff409a5fc3712d42b3cd4c3bb86dff28948a", "max_issues_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-04-06T19:20:14.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-06T19:20:14.000Z", "max_forks_repo_path": "docs/autodidax.py", "max_forks_repo_name": "jotsif/jax", "max_forks_repo_head_hexsha": "9bffe1ad05ea7e6657a35d3032cd04877296381a", "max_forks_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-06-02T00:46:47.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-02T00:46:47.000Z", "avg_line_length": 31.3390639924, "max_line_length": 84, "alphanum_fraction": 0.7101365354, "include": true, "reason": "import numpy", "num_tokens": 9157, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4687906266262437, "lm_q2_score": 0.136608397056381, "lm_q1q2_score": 0.06404073605846755}}
{"text": "\"\"\"\n.. _tut-fnirs-processing-bad:\n\nImportance of Controls and Parameter Selection\n==============================================\n\n.. warning:: DO NOT USE THIS SCRIPT TO PROCESS YOUR DATA\n\n.. sidebar:: Relevant literature\n\n   Huppert TJ. Commentary on the statistical properties of noise and its\n   implication on general linear models in functional near-infrared\n   spectroscopy. Neurophotonics. 2016;3(1)\n\nThis tutorial demonstrates how **NOT** to process your\nfunctional near-infrared spectroscopy (fNIRS)\ndata.\nHere I demonstrate that with a simple process pipelines even random noise\ncan look like a canonical haemodynamic response.\n\nThis tutorial was written to motivate further interest in to what affect\nsignal processing has on our data. And to provide a concrete example\nabout why you should understand your analysis and not vary parameters to meet\npreconceived ideas of what your data should look like.\nI recommend specifying analysis parameters in advance along with your experimental\nprotocol. Hopefully this tutorial also highlights the importance of\nincluding a control condition in your experimental design.\n\nThe\n:ref:`MNE fNIRS waveform tutorial <mne:tut-fnirs-processing>`\nis used as a basis for this analysis, so most of the document looks similar.\nHowever, at the midpoint we replace the real data with noise and demonstrate\nthat without careful attention to the analysis parameter it would still\nappear as if a fNIRS response is observed.\n\n\n.. contents:: Page contents\n   :local:\n   :depth: 2\n\n\"\"\"\n# sphinx_gallery_thumbnail_number = 7\n\n\n# Authors: Robert Luke <mail@robertluke.net>\n#\n# License: BSD (3-clause)\n\nimport os\nimport numpy as np\n\nimport mne\nimport mne_nirs\nnp.random.seed(1)\n\nfnirs_data_folder = mne.datasets.fnirs_motor.data_path()\nfnirs_cw_amplitude_dir = os.path.join(fnirs_data_folder, 'Participant-1')\nraw_intensity = mne.io.read_raw_nirx(fnirs_cw_amplitude_dir, verbose=True)\nraw_intensity.load_data()\n\n\n# %%\n# Selecting channels appropriate for detecting neural responses\n# -------------------------------------------------------------\n#\n# First we remove channels that are too close together (short channels) to\n# detect a neural response (less than 1 cm distance between optodes).\n# These short channels can be seen in the figure above.\n# To achieve this we pick all the channels that are not considered to be short.\n\npicks = mne.pick_types(raw_intensity.info, meg=False, fnirs=True)\ndists = mne.preprocessing.nirs.source_detector_distances(\n    raw_intensity.info, picks=picks)\nraw_intensity.pick(picks[dists > 0.01])\nraw_intensity.plot(n_channels=len(raw_intensity.ch_names),\n                   duration=500, show_scrollbars=False)\n\n\n# %%\n# Converting from raw intensity to optical density\n# ------------------------------------------------\n#\n# The raw intensity values are then converted to optical density.\n\nraw_od = mne.preprocessing.nirs.optical_density(raw_intensity)\nraw_od.plot(n_channels=len(raw_od.ch_names),\n            duration=500, show_scrollbars=False)\n\n\n# %%\n# Converting from optical density to haemoglobin\n# ----------------------------------------------\n#\n# Next we convert the optical density data to haemoglobin concentration using\n# the modified Beer-Lambert law.\n\nraw_haemo = mne.preprocessing.nirs.beer_lambert_law(raw_od)\nraw_haemo.plot(n_channels=len(raw_haemo.ch_names),\n               duration=500, show_scrollbars=False)\n\n\n\n# %%\n# !!!!!!Replace real data with white noise!!!!!\n# ----------------------------------------------\n#\n# Here we replace the signals with white noise.\n# We make the HbR white noise 3 time smaller than HbO as is commonly observed.\n\n\nraw_haemo._data = np.random.randn(40, 23239) / 1.0e6 * 1\nraw_haemo._data[::2, :]= np.random.randn(20, 23239) / 1.0e6 * 3\n\n\n# %%\n# Removing heart rate from signal (BAD DONT COPY)\n# -----------------------------------------------\n#\n# This analysis is BAD and is provided just as a demonstration.\n# Do not do this!!\n#\n\nfig = raw_haemo.plot_psd(average=True)\nfig.suptitle('Before filtering', weight='bold', size='x-large')\nfig.subplots_adjust(top=0.88)\nraw_haemo = raw_haemo.filter(0.05, 0.1, h_trans_bandwidth=0.2,\n                             l_trans_bandwidth=0.02)\nfig = raw_haemo.plot_psd(average=True)\nfig.suptitle('After filtering', weight='bold', size='x-large')\nfig.subplots_adjust(top=0.88)\n\n\n# %%\n# Apply Cui negative correlation method\n# -------------------------------------\n#\n# Here we apply the Cui signal enhancement technique.\n\nraw_haemo = mne_nirs.signal_enhancement.enhance_negative_correlation(raw_haemo)\n\n\n# %%\n# Extract epochs\n# --------------\n#\n# Now that the signal has been converted to relative haemoglobin concentration,\n# and the unwanted heart rate component has been removed, we can extract epochs\n# related to each of the experimental conditions.\n#\n# First we extract the events of interest and visualise them to ensure they are\n# correct.\n\nevents, _ = mne.events_from_annotations(raw_haemo, event_id={'1.0': 1,\n                                                             '2.0': 2,\n                                                             '3.0': 3})\nevent_dict = {'Control': 1, 'Tapping/Left': 2, 'Tapping/Right': 3}\nfig = mne.viz.plot_events(events, event_id=event_dict,\n                          sfreq=raw_haemo.info['sfreq'])\nfig.subplots_adjust(right=0.7)  # make room for the legend\n\n\n# %%\n# Next we define the range of our epochs, the rejection criteria,\n# baseline correction, and extract the epochs. We visualise the log of which\n# epochs were dropped.\n\nreject_criteria = dict(hbo=10e-6)\ntmin, tmax = -1.5, 10.5\n\nepochs = mne.Epochs(raw_haemo, events, event_id=event_dict,\n                    tmin=tmin, tmax=tmax,\n                    reject=reject_criteria, reject_by_annotation=True,\n                    proj=True, baseline=(None, 0), preload=True,\n                    detrend=1, verbose=True)\n\n\n# %%\n# Plot standard fNIRS response image\n# ----------------------------------\n#\n# Next we generate the most common visualisation of fNIRS data: plotting\n# both the HbO and HbR on the same figure to illustrate the relation between\n# the two signals.\n\nevoked_dict = {'Tapping/HbO': epochs['Tapping'].average(picks='hbo'),\n               'Tapping/HbR': epochs['Tapping'].average(picks='hbr')}\n\n# Rename channels until the encoding of frequency in ch_name is fixed\nfor condition in evoked_dict:\n    evoked_dict[condition].rename_channels(lambda x: x[:-4])\n\ncolor_dict = dict(HbO='#AA3377', HbR='b')\n\nmne.viz.plot_compare_evokeds(evoked_dict, combine=\"mean\", ci=0.95,\n                             colors=color_dict)\n\n\n# %%\n# Summary\n# --------------\n#\n# Above is a waveform that has many of the characteristics that are expected\n# from a haeomodynamic response.\n# We see a baseline that is around zero, the oxyhaemoglobin is positive\n# and the deoxyhaemoglobin is negative,\n# the peak occurs around 5 seconds then returns to\n# baseline.\n# However, it was generated from random noise!\n#\n# .. sidebar:: PLEASE READ THIS PAPER!!\n#\n#    Huppert TJ. Commentary on the statistical properties of noise and its\n#    implication on general linear models in functional near-infrared\n#    spectroscopy. Neurophotonics. 2016;3(1)\n#\n# As this is an introduction tutorial I do not go in to details about the\n# signal process theory behind why the settings above are wrong.\n# But if you are interested you should start with a DSP textbook\n# on signals and systems.\n#\n# There are many signal processing parameter choices that interact to produce\n# your end result. It is important to have a control condition to ensure\n# that you aren't forcing your data to have these fake responses.\n# Its also important to understand the effect that each parameter choice\n# has on your output. Using a receiver operating characteristic is a good\n# approach to understand your analysis.\n# This also highlights some of the concerns with the time domain analysis\n# approach, and the benefits of the GLM style of analysis\n# :ref:`(see MNE-NIRS fNIRS GLM tutorial) <tut-fnirs-hrf>` (and Huppert 2016).\n#\n# .. warning:: DO NOT USE THIS SCRIPT TO PROCESS YOUR DATA\n", "meta": {"hexsha": "0bdcd0b81990d59567508101d8144f18885e1e8f", "size": 8090, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/general/plot_99_bad.py", "max_stars_repo_name": "drammock/mne-nirs", "max_stars_repo_head_hexsha": "2deb73184b4609d0a72495e65565f430bbff0704", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/general/plot_99_bad.py", "max_issues_repo_name": "drammock/mne-nirs", "max_issues_repo_head_hexsha": "2deb73184b4609d0a72495e65565f430bbff0704", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/general/plot_99_bad.py", "max_forks_repo_name": "drammock/mne-nirs", "max_forks_repo_head_hexsha": "2deb73184b4609d0a72495e65565f430bbff0704", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.8706896552, "max_line_length": 82, "alphanum_fraction": 0.69592089, "include": true, "reason": "import numpy", "num_tokens": 1901, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4687906266262437, "lm_q2_score": 0.136608388268679, "lm_q1q2_score": 0.06404073193887523}}
{"text": "# -*- coding: utf-8 -*-\n\"\"\"\nExamples of Sandpile\n\nAUTHORS:\n\n- David Perkinson (2015-05) [Using `examples.py` from homology as\n  template.]\n\nThis file constructs some examples of Sandpiles.\n\nThe examples are accessible by typing ``sandpiles.NAME``, where\n``NAME`` is the name of the example.  You can get a list by typing\n``sandpiles.`` and hitting the TAB key::\n\n   sandpiles.Complete\n   sandpiles.Cycle\n   sandpiles.Diamond\n   sandpiles.Grid\n   sandpiles.House\n\nSee the documentation for each particular type of example for full details.\n\"\"\"\n\nfrom sage.sandpiles.sandpile import Sandpile\nfrom sage.graphs.graph_generators import graphs\n\nclass SandpileExamples(object):\n    \"\"\"\n    Some examples of sandpiles.\n\n    Here are the available examples; you can also type\n    ``sandpiles.``  and hit tab to get a list:\n\n    - :meth:`Complete`\n    - :meth:`Cycle`\n    - :meth:`Diamond`\n    - :meth:`Grid`\n    - :meth:`House`\n\n    EXAMPLES::\n\n        sage: s = sandpiles.Complete(4)\n        sage: s.invariant_factors()\n        [1, 4, 4]\n        sage: s.laplacian()\n        [ 3 -1 -1 -1]\n        [-1  3 -1 -1]\n        [-1 -1  3 -1]\n        [-1 -1 -1  3]\n    \"\"\"\n    def __call__(self):\n        r\"\"\"\n        If sandpiles() is executed, return a helpful message.\n\n        INPUT:\n\n        None\n\n        OUTPUT:\n\n        None\n\n        EXAMPLES::\n\n            sage: sandpiles()\n            Try sandpile.FOO() where FOO is in the list:\n            <BLANKLINE>\n                Complete, Cycle, Diamond, Fan, Grid, House, Wheel\n        \"\"\"\n        print 'Try sandpile.FOO() where FOO is in the list:\\n'\n        print \"    \" + \", \".join([str(i) for i in dir(sandpiles) if i[0]!='_'])\n\n    def Complete(self, n):\n        \"\"\"\n        The complete sandpile graph with `n` vertices.\n\n        INPUT:\n\n        -  ``n`` -- positive integer\n\n        OUTPUT:\n\n        - Sandpile\n\n        EXAMPLES::\n\n            sage: s = sandpiles.Complete(4)\n            sage: s.group_order()\n            16\n            sage: sandpiles.Complete(3) == sandpiles.Cycle(3)\n            True\n        \"\"\"\n        return Sandpile(graphs.CompleteGraph(n),0)\n\n    def Cycle(self, n):\n        \"\"\"\n        Sandpile on the cycle graph with `n` vertices.\n\n        INPUT:\n\n        -  ``n`` -- a non-negative integer\n\n        OUTPUT:\n\n        - Sandpile\n\n        EXAMPLES::\n\n            sage: s = sandpiles.Cycle(4)\n            sage: s.edges()\n            [(0, 1, 1),\n             (0, 3, 1),\n             (1, 0, 1),\n             (1, 2, 1),\n             (2, 1, 1),\n             (2, 3, 1),\n             (3, 0, 1),\n             (3, 2, 1)]\n        \"\"\"\n        return Sandpile(graphs.CycleGraph(n),0)\n\n    def Diamond(self):\n        \"\"\"\n        Sandpile on the diamond graph.\n\n        INPUT:\n\n        None\n\n        OUTPUT:\n\n        - Sandpile\n\n        EXAMPLES::\n\n            sage: s = sandpiles.Diamond()\n            sage: s.invariant_factors()\n            [1, 1, 8]\n        \"\"\"\n        return Sandpile(graphs.DiamondGraph(),0)\n\n\n    def Fan(self, n, deg_three_verts=False):\n        \"\"\"\n        Sandpile on the Fan graph with a total of `n` vertices.\n\n        INPUT:\n\n        -  ``n`` -- a non-negative integer\n\n        OUTPUT:\n\n        - Sandpile\n\n        EXAMPLES::\n\n            sage: f = sandpiles.Fan(10)\n            sage: f.group_order() == fibonacci(18)\n            True\n            sage: f = sandpiles.Fan(10,True)  # all nonsink vertices have deg 3\n            sage: f.group_order() == fibonacci(20)\n            True\n        \"\"\"\n        f = graphs.WheelGraph(n)\n        if n>2:\n            f.delete_edge(1,n-1)\n            if deg_three_verts:\n                f.allow_multiple_edges(True)\n                f.add_edges([(0,1),(0,n-1)])\n            return Sandpile(f,0)\n        elif n==1:\n            return Sandpile(f,0)\n        elif n==2:\n            if deg_three_verts:\n                return Sandpile({0:{1:3}, 1:{0:3}})\n            else:\n                return Sandpile(f,0)\n\n    def Grid(self, m, n):\n        \"\"\"\n        Sandpile on the diamond graph.\n\n        INPUT:\n\n        -  ``m``, ``n`` -- negative integers\n\n        OUTPUT:\n\n        - Sandpile\n\n        EXAMPLES::\n\n            sage: s = sandpiles.Grid(2,3)\n            sage: s.vertices()\n            [(0, 0), (1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3)]\n            sage: s.invariant_factors()\n            [1, 1, 1, 1, 1, 2415]\n            sage: s = sandpiles.Grid(1,1)\n            sage: s.dict()\n            {(0, 0): {(1, 1): 4}, (1, 1): {(0, 0): 4}}\n        \"\"\"\n        G = graphs.Grid2dGraph(m+2,n+2)\n        G.allow_multiple_edges(True)  # to ensure each vertex ends up with degree 4\n        V = [(i,j) for i in [0,m+1] for j in range(n+2)] + [(i,j) for j in [0,n+1] for i in range(m+2)]\n        G.merge_vertices(V)\n        return Sandpile(G, (0,0))\n\n    def House(self):\n        \"\"\"\n        Sandpile on the House graph.\n\n        INPUT:\n\n        None\n\n        OUTPUT:\n\n        - Sandpile\n\n        EXAMPLES::\n\n            sage: s = sandpiles.House()\n            sage: s.invariant_factors()\n            [1, 1, 1, 11]\n        \"\"\"\n        return Sandpile(graphs.HouseGraph(),0)\n\n    def Wheel(self, n):\n        \"\"\"\n        Sandpile on the wheel graph with a total of `n` vertices.\n\n        INPUT:\n\n        -  ``n`` -- a non-negative integer\n\n        OUTPUT:\n\n        - Sandpile\n\n        EXAMPLES::\n\n            sage: w = sandpiles.Wheel(6)\n            sage: w.invariant_factors()\n            [1, 1, 1, 11, 11]\n        \"\"\"\n        return Sandpile(graphs.WheelGraph(n),0)\n\nsandpiles = SandpileExamples()\n", "meta": {"hexsha": "5240d9515fcaf0f89e0cf4a9ff71f59849e1b78a", "size": 5511, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/sandpiles/examples.py", "max_stars_repo_name": "switzel/sage", "max_stars_repo_head_hexsha": "7eb8510dacf61b691664cd8f1d2e75e5d473e5a0", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/sage/sandpiles/examples.py", "max_issues_repo_name": "switzel/sage", "max_issues_repo_head_hexsha": "7eb8510dacf61b691664cd8f1d2e75e5d473e5a0", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/sandpiles/examples.py", "max_forks_repo_name": "switzel/sage", "max_forks_repo_head_hexsha": "7eb8510dacf61b691664cd8f1d2e75e5d473e5a0", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-07-24T12:20:37.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-24T12:20:37.000Z", "avg_line_length": 22.044, "max_line_length": 103, "alphanum_fraction": 0.4877517692, "include": true, "reason": "from sage", "num_tokens": 1533, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4649015713733885, "lm_q2_score": 0.136608397056381, "lm_q1q2_score": 0.06350945845431132}}
{"text": "r\"\"\".. role:: html(raw)\r\n   :format: html\r\n\r\nUnderstanding the Haar Measure\r\n==============================\r\n\r\n.. meta::\r\n    :property=\"og:description\": Learn all about the Haar measure and how to randomly sample quantum states.\r\n\r\n    :property=\"og:image\": https://pennylane.ai/qml/_images/spherical_int_dtheta.png\r\n\r\n.. related::\r\n\r\n    tutorial_unitary_designs Unitary designs\r\n    quantum_volume Quantum volume\r\n    qsim_beyond_classical Beyond classical computing with qsim\r\n    tutorial_barren_plateaus Barren plateaus\r\n\r\n\r\n*Author: PennyLane dev team. Posted: 22 March 2021. Last updated: 22 March 2021.*\r\n\r\nIf you've ever dug into the literature about random quantum circuits,\r\nvariational ansatz structure, or anything related to the structure and\r\nproperties of unitary operations, you've likely come across a statement like the\r\nfollowing: \"Assume that :math:`U` is sampled uniformly at random from the Haar\r\nmeasure\".  In this demo, we're going to unravel this cryptic statement and take\r\nan in-depth look at what it means. You'll gain an understanding of the general\r\nconcept of *measure*, the Haar measure and its special properties, and you'll\r\nlearn how to sample from it using tools available in PennyLane and other\r\nscientific computing frameworks. By the end of this demo, you'll be able to\r\ninclude that important statement in your own work with confidence!\r\n\r\n.. note::\r\n\r\n   To get the most out of this demo, it is helpful if you are familiar with\r\n   `integration of multi-dimensional functions\r\n   <https://en.wikipedia.org/wiki/Multiple_integral>`__, the `Bloch sphere\r\n   <https://en.wikipedia.org/wiki/Bloch_sphere>`__, and the conceptual ideas\r\n   behind `decompositions\r\n   <https://en.wikipedia.org/wiki/Matrix_decomposition>`__ and factorizations of\r\n   unitary matrices (see, e.g., 4.5.1 and 4.5.2 of [#NandC2000]_).\r\n\r\nMeasure\r\n-------\r\n\r\n`Measure theory <https://en.wikipedia.org/wiki/Measure_(mathematics)>`__ is a\r\nbranch of mathematics that studies things that are measurable---think length,\r\narea, or volume, but generalized to mathematical spaces and even higher\r\ndimensions. Loosely, the measure tells you about how \"stuff\" is distributed and\r\nconcentrated in a mathematical set or space. An intuitive way to understand\r\nmeasure is to think about a sphere. An arbitrary point on a sphere can be\r\nparametrized by three numbers---depending on what you're doing, you may use\r\nCartesian coordinates :math:`(x, y, z)`, or it may be more convenient to use\r\nspherical coordinates :math:`(\\rho, \\phi, \\theta)`.\r\n\r\nSuppose you wanted to compute the volume of a solid sphere with radius\r\n:math:`r`.  This can be done by integrating over the three coordinates\r\n:math:`\\rho, \\phi`, and :math:`\\theta`. Your first thought here may be to simply\r\nintegrate each parameter over its full range, like so:\r\n\r\n.. math::\r\n\r\n    V = \\int_0^{r} \\int_0^{2\\pi} \\int_0^{\\pi} d\\rho~ d\\phi~ d\\theta = 2\\pi^2 r\r\n\r\nBut, we know that the volume of a sphere of radius :math:`r` is\r\n:math:`\\frac{4}{3}\\pi r^3`, so what we got from this integral is clearly wrong!\r\nTaking the integral naively like this doesn't take into account the structure of\r\nthe sphere with respect to the parameters. For example, consider\r\ntwo small, infinitesimal elements of area with the same difference in\r\n:math:`\\theta` and :math:`\\phi`, but at different values of :math:`\\theta`:\r\n\r\n.. figure:: /demonstrations/haar_measure/spherical_int_dtheta.png\r\n    :align: center\r\n    :width: 50%\r\n\r\n    |\r\n\r\nEven though the differences :math:`d\\theta` and :math:`d\\phi` themselves are the\r\nsame, there is way more \"stuff\" near the equator of the sphere than there is\r\nnear the poles. We must take into account the value of :math:`\\theta` when\r\ncomputing the integral! Specifically, we multiply by the function\r\n:math:`\\sin\\theta`---the properties of the :math:`\\sin` function mean that the\r\nmost weight will occur around the equator where :math:`\\theta=\\pi/2`, and the\r\nleast weight near the poles where :math:`\\theta=0` and :math:`\\theta=\\pi`.\r\n\r\nSimilar care must be taken for :math:`\\rho`.  The contribution to volume of\r\nparts of the sphere with a large :math:`\\rho` is far more than for a small\r\n:math:`\\rho`---we should expect the contribution to be proportional to\r\n:math:`\\rho^2`, given that the surface area of a sphere of radius :math:`r` is\r\n:math:`4\\pi r^2`.\r\n\r\nOn the other hand, for a fixed :math:`\\rho` and :math:`\\theta`, the length of\r\nthe :math:`d\\phi` is the same all around the circle. If put all these facts\r\ntogether, we find that the actual expression for the integral should look like\r\nthis:\r\n\r\n.. math::\r\n\r\n    V = \\int_0^r \\int_0^{2\\pi} \\int_0^{\\pi} \\rho^2 \\sin \\theta~ d\\rho~ d\\phi~\r\n    d\\theta = \\frac{4}{3}\\pi r^3\r\n\r\nThese extra terms that we had to add to the integral, :math:`\\rho^2 \\sin\r\n\\theta`, constitute the *measure*. The measure weights portions of the sphere\r\ndifferently depending on where they are in the space. While we need to know the\r\nmeasure to properly integrate over the sphere, knowledge of the measure also\r\ngives us the means to perform another important task, that of sampling points in\r\nthe space uniformly at random. We can't simply sample each parameter from the\r\nuniform distribution over its domain---as we experienced already, this doesn't\r\ntake into account how the sphere is spread out over space. The measure describes\r\nthe distribution of each parameter and gives a recipe for sampling them in order\r\nto obtain something properly uniform.\r\n\r\nThe Haar measure\r\n----------------\r\n\r\nOperations in quantum computing are described by unitary matrices.\r\nUnitary matrices, like points on a sphere, can be expressed in terms of a fixed\r\nset of coordinates, or parameters. For example, the most general single-qubit rotation\r\nimplemented in PennyLane (:class:`~.pennylane.Rot`) is expressed in terms of three\r\nparameters like so,\r\n\r\n.. math::\r\n\r\n    U(\\phi, \\theta, \\omega) = \\begin{pmatrix} e^{-i(\\phi + \\omega)/2}\r\n                        \\cos(\\theta/2) & -e^{i(\\phi - \\omega)/2} \\sin(\\theta/2)\r\n                        \\\\ e^{-i(\\phi - \\omega)/2} \\sin(\\theta/2) & e^{i(\\phi +\r\n                        \\omega)/2} \\cos(\\theta/2) \\end{pmatrix}.\r\n\r\nFor every dimension :math:`N`, the unitary matrices of size :math:`N \\times N`\r\nconstitute the *unitary group* :math:`U(N)`. We can perform operations on\r\nelements of this group, such as apply functions to them, integrate over them, or\r\nsample uniformly over them, just as we can do to points on a sphere. When we do\r\nsuch tasks with respect to the sphere, we have to add the measure in order to\r\nproperly weight the different regions of space. The *Haar measure* provides the\r\nanalogous terms we need for working with the unitary group.\r\n\r\nFor an :math:`N`-dimensional system, the Haar measure, often denoted by\r\n:math:`\\mu_N`, tells us how to weight the elements of :math:`U(N)`. For\r\nexample, suppose :math:`f` is a function that acts on elements of :math:`U(N)`,\r\nand we would like to take its integral over the group. We must write this\r\nintegral with respect to the Haar measure, like so:\r\n\r\n.. math::\r\n\r\n    \\int_{V \\in U(N)} f(V) d\\mu_N(V).\r\n\r\nAs with the measure term of the sphere, :math:`d\\mu_N` itself can be broken down\r\ninto components depending on individual parameters.  While the Haar\r\nmeasure can be defined for every dimension :math:`N`, the mathematical form gets\r\nquite hairy for larger dimensions---in general, an :math:`N`-dimensional unitary\r\nrequires at least :math:`N^2 - 1` parameters, which is a lot to keep track of!\r\nTherefore we'll start with the case of a single qubit :math:`(N=2)`, then show\r\nhow things generalize.\r\n\r\nSingle-qubit Haar measure\r\n~~~~~~~~~~~~~~~~~~~~~~~~~\r\n\r\nThe single-qubit case provides a particularly nice entry point because we can\r\ncontinue our comparison to spheres by visualizing single-qubit states on the\r\nBloch sphere. As expressed above, the measure provides a recipe for sampling\r\nelements of the unitary group in a properly uniform manner, given the structure\r\nof the group. One useful consequence of this is that it provides a method to\r\nsample quantum *states* uniformly at random---we simply generate Haar-random\r\nunitaries, and apply them to a fixed basis state such as :math:`\\vert 0\\rangle`.\r\n\r\nWe'll see how this works in good time. First, we'll take a look at what happens\r\nwhen we ignore the measure and do things *wrong*. Suppose we sample quantum\r\nstates by applying unitaries obtained by the parametrization above, but sample\r\nthe angles :math:`\\omega, \\phi`, and :math:`\\theta` from the flat uniform\r\ndistribution between :math:`[0, 2\\pi)` (fun fact: there is a measure implicit in\r\nthis kind of sampling too! It just has a constant value, because each point is\r\nequally likely to be sampled).\r\n\r\n\"\"\"\r\n\r\nimport pennylane as qml\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\n\r\n# set the random seed\r\nnp.random.seed(42)\r\n\r\n# Use the mixed state simulator to save some steps in plotting later\r\ndev = qml.device('default.mixed', wires=1)\r\n\r\n@qml.qnode(dev)\r\ndef not_a_haar_random_unitary():\r\n    # Sample all parameters from their flat uniform distribution\r\n    phi, theta, omega = 2 * np.pi * np.random.uniform(size=3)\r\n    qml.Rot(phi, theta, omega, wires=0)\r\n    return qml.state()\r\n\r\nnum_samples = 2021\r\n\r\nnot_haar_samples = [not_a_haar_random_unitary() for _ in range(num_samples)]\r\n\r\n######################################################################\r\n# In order to plot these on the Bloch sphere, we'll need to do one more\r\n# step, and convert the quantum states into Bloch vectors.\r\n#\r\n\r\nX = np.array([[0, 1], [1, 0]])\r\nY = np.array([[0, -1j], [1j, 0]])\r\nZ = np.array([[1, 0], [0, -1]])\r\n\r\n# Used the mixed state simulator so we could have the density matrix for this part!\r\ndef convert_to_bloch_vector(rho):\r\n    \"\"\"Convert a density matrix to a Bloch vector.\"\"\"\r\n    ax = np.trace(np.dot(rho, X)).real\r\n    ay = np.trace(np.dot(rho, Y)).real\r\n    az = np.trace(np.dot(rho, Z)).real\r\n    return [ax, ay, az]\r\n\r\nnot_haar_bloch_vectors = np.array([convert_to_bloch_vector(s) for s in not_haar_samples])\r\n\r\n######################################################################\r\n# With this done, let's find out where our \"uniformly random\" states ended up:\r\n\r\ndef plot_bloch_sphere(bloch_vectors):\r\n    \"\"\" Helper function to plot vectors on a sphere.\"\"\"\r\n    fig = plt.figure(figsize=(6, 6))\r\n    ax = fig.add_subplot(111, projection='3d')\r\n    fig.subplots_adjust(left=0, right=1, bottom=0, top=1)\r\n\r\n    ax.grid(False)\r\n    ax.set_axis_off()\r\n    ax.view_init(30, 45)\r\n    ax.dist = 7\r\n\r\n    # Draw the axes (source: https://github.com/matplotlib/matplotlib/issues/13575)\r\n    x, y, z = np.array([[-1.5,0,0], [0,-1.5,0], [0,0,-1.5]])\r\n    u, v, w = np.array([[3,0,0], [0,3,0], [0,0,3]])\r\n    ax.quiver(x, y, z, u, v, w, arrow_length_ratio=0.05, color=\"black\", linewidth=0.5)\r\n\r\n    ax.text(0, 0, 1.7, r\"|0⟩\", color=\"black\", fontsize=16)\r\n    ax.text(0, 0, -1.9, r\"|1⟩\", color=\"black\", fontsize=16)\r\n    ax.text(1.9, 0, 0, r\"|+⟩\", color=\"black\", fontsize=16)\r\n    ax.text(-1.7, 0, 0, r\"|–⟩\", color=\"black\", fontsize=16)\r\n    ax.text(0, 1.7, 0, r\"|i+⟩\", color=\"black\", fontsize=16)\r\n    ax.text(0,-1.9, 0, r\"|i–⟩\", color=\"black\", fontsize=16)\r\n\r\n    ax.scatter(\r\n        bloch_vectors[:,0], bloch_vectors[:,1], bloch_vectors[:, 2], c='#e29d9e', alpha=0.3\r\n    )\r\n\r\nplot_bloch_sphere(not_haar_bloch_vectors)\r\n\r\n######################################################################\r\n# You can see from this plot that even though our parameters were sampled from a\r\n# uniform distribution, there is a noticeable amount of clustering around the poles\r\n# of the sphere. Despite the input parameters being uniform, the output is very\r\n# much *not* uniform. Just like the regular sphere, the measure is larger near\r\n# the equator, and if we just sample uniformly, we won't end up populating that\r\n# area as much. To take that into account we will need to sample from the proper\r\n# Haar measure, and weight the different parameters appropriately.\r\n#\r\n# For a single qubit, the Haar measure looks much like the case of a sphere,\r\n# minus the radial component. Intuitively, all qubit state vectors have length\r\n# 1, so it makes sense that this wouldn't play a role here. The parameter that\r\n# we will have to weight differently is :math:`\\theta`, and in fact the\r\n# adjustment in measure is identical to that we had to do with the polar axis of\r\n# the sphere, i.e., :math:`\\sin \\theta`. In order to sample the :math:`\\theta`\r\n# uniformly at random in this context, we must sample from the distribution\r\n# :math:`\\hbox{Pr}(\\theta) = \\sin \\theta`. We can accomplish this by setting up\r\n# a custom probability distribution with \r\n# `rv_continuous <https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.rv_continuous.html#scipy.stats.rv_continuous>`__\r\n# in ``scipy``.\r\n\r\nfrom scipy.stats import rv_continuous\r\n\r\nclass sin_prob_dist(rv_continuous):\r\n    def _pdf(self, theta):\r\n        # The 0.5 is so that the distribution is normalized\r\n        return 0.5 * np.sin(theta)\r\n\r\n# Samples of theta should be drawn from between 0 and pi\r\nsin_sampler = sin_prob_dist(a=0, b=np.pi)\r\n\r\n@qml.qnode(dev)\r\ndef haar_random_unitary():\r\n    phi, omega = 2 * np.pi * np.random.uniform(size=2) # Sample phi and omega as normal\r\n    theta = sin_sampler.rvs(size=1) # Sample theta from our new distribution\r\n    qml.Rot(phi, theta, omega, wires=0)\r\n    return qml.state()\r\n\r\nhaar_samples = [haar_random_unitary() for _ in range(num_samples)]\r\nhaar_bloch_vectors = np.array([convert_to_bloch_vector(s) for s in haar_samples])\r\n\r\nplot_bloch_sphere(haar_bloch_vectors)\r\n\r\n######################################################################\r\n# We see that when we use the correct measure, our qubit states are now\r\n# much better distributed over the sphere. Putting this information together,\r\n# we can now write the explicit form for the single-qubit Haar measure:\r\n#\r\n# .. math::\r\n#\r\n#    d\\mu_2 = \\sin \\theta d\\theta \\cdot d\\omega \\cdot d\\phi.\r\n# \r\n# Show me more math!\r\n# ~~~~~~~~~~~~~~~~~~\r\n#\r\n# While we can easily visualize the single-qubit case, this is no longer\r\n# possible when we increase the number of qubits. Regardless, we can still\r\n# obtain a mathematical expression for the Haar measure in arbitrary\r\n# dimensions. In the previous section, we expressed the Haar measure in terms of\r\n# a set of parameters that can be used to specify the unitary group\r\n# :math:`U(2)`. Such a parametrization is not unique, and in fact there are\r\n# multiple ways to *factorize*, or decompose an :math:`N`-dimensional unitary\r\n# operation into a set of parameters.\r\n#\r\n# Many of these parametrizations come to us from the study of photonics.  Here,\r\n# arbitrary operations are broken down into elementary operations involving only\r\n# a few parameters which correspond directly to parameters of the physical\r\n# apparatus used to implement them (beamsplitters and phase shifts). Rather than\r\n# qubits, such operations act on modes, or *qumodes*. They are expressed as\r\n# elements of the :math:`N`-dimensional `special unitary group\r\n# <https://en.wikipedia.org/wiki/Special_unitary_group>`__. This group, written\r\n# as :math:`SU(N)`, is the continuous group consisting of all :math:`N \\times N`\r\n# unitary operations with determinant 1 (essentially like :math:`U(N)`, minus\r\n# a potential global phase).\r\n#\r\n#\r\n# .. note::\r\n#\r\n#     Elements of :math:`SU(N)` and :math:`U(N)` can still be considered as\r\n#     multi-qubit operations in the cases where :math:`N` is a power of 2, but\r\n#     they must be translated from continuous-variable operations into qubit\r\n#     operations. (In PennyLane, this can be done by feeding the unitaries to\r\n#     the :class:`~.pennylane.QubitUnitary` operation directly. Alternatively,\r\n#     one can use *quantum compilation* to express the operations as a sequence\r\n#     of elementary gates such as Pauli rotations and CNOTs.)\r\n#\r\n# .. admonition:: Tip\r\n#\r\n#    If you haven't had many opportunities to work in terms of qumodes, the\r\n#    `Strawberry Fields documentation\r\n#    <https://strawberryfields.ai/photonics/concepts/photonics.html>`__ is a\r\n#    good starting point.\r\n#\r\n# For example, we saw already above that for :math:`N=2`, we can write\r\n#\r\n# .. math::\r\n#\r\n#    U(\\phi, \\theta, \\omega) = \\begin{pmatrix} e^{-i(\\phi + \\omega)/2}\r\n#                        \\cos(\\theta/2) & -e^{i(\\phi - \\omega)/2} \\sin(\\theta/2)\r\n#                        \\\\ e^{-i(\\phi - \\omega)/2} \\sin(\\theta/2) & e^{i(\\phi +\r\n#                        \\omega)/2} \\cos(\\theta/2) \\end{pmatrix}.\r\n#\r\n#\r\n# This unitary can be factorized as follows: \r\n#\r\n# .. math::\r\n#\r\n#    U(\\phi, \\theta, \\omega) =\r\n#        \\begin{pmatrix}\r\n#          e^{-i\\omega/2} & 0 \\\\ 0 & e^{i\\omega/2}\r\n#        \\end{pmatrix}\r\n#        \\begin{pmatrix}\r\n#          \\cos(\\theta/2) & -\\sin(\\theta/2) \\\\ \\sin(\\theta/2) & \\cos(\\theta/2)\r\n#        \\end{pmatrix}\r\n#       \\begin{pmatrix}\r\n#          e^{-i\\phi/2} & 0 \\\\ 0 & e^{i\\phi/2}\r\n#        \\end{pmatrix}\r\n#\r\n# The middle operation is a beamsplitter; the other two operations are phase\r\n# shifts.  We saw earlier that for :math:`N=2`, :math:`d\\mu_2 = \\sin\\theta\r\n# d\\theta d\\omega d\\phi`---note how the parameter in the beamsplitter\r\n# contributes to the measure in a different way than those of the phase\r\n# shifts. As mentioned above, for larger values of :math:`N` there are multiple\r\n# ways to decompose the unitary. Such decompositions rewrite elements in\r\n# :math:`SU(N)` acting on :math:`N` modes as a sequence of operations acting\r\n# only on 2 modes, :math:`SU(2)`, and single-mode phase shifts.  Shown below are\r\n# three examples [#deGuise2018]_, [#Clements2016]_, [#Reck1994]_:\r\n#\r\n# .. figure:: /demonstrations/haar_measure/unitaries.png\r\n#    :align: center\r\n#    :width: 95%\r\n#\r\n#\r\n# In these graphics, every wire is a different mode. Every box represents an\r\n# operation on one or more modes, and the number in the box indicates the number\r\n# of parameters.  The boxes containing a ``1`` are simply phase shifts on\r\n# individual modes. The blocks containing a ``3`` are :math:`SU(2)` transforms\r\n# with 3 parameters, such as the :math:`U(\\phi, \\theta, \\omega)` above. Those\r\n# containing a ``2`` are :math:`SU(2)` transforms on pairs of modes with 2\r\n# parameters, similar to the 3-parameter ones but with :math:`\\omega = \\phi`.\r\n#\r\n# Although the decompositions all produce the same set of operations, their\r\n# structure and parametrization may have consequences in practice.  The first [#deGuise2018]_\r\n# has a particularly convenient form that leads to a recursive definition\r\n# of the Haar measure. The decomposition is formulated recursively such that an\r\n# :math:`SU(N)` operation can be implemented by sandwiching an :math:`SU(2)`\r\n# transformation between two :math:`SU(N-1)` transformations, like so:\r\n#\r\n# |\r\n#\r\n# .. figure:: /demonstrations/haar_measure/sun.svg\r\n#    :align: center\r\n#    :width: 80%\r\n#\r\n# |\r\n#\r\n# The Haar measure is then constructed recursively as a product of 3\r\n# terms. The first term depends on the parameters in the first :math:`SU(N-1)`\r\n# transformation; the second depends on the parameters in the lone :math:`SU(2)`\r\n# transformation; and the third term depends on the parameters in the other\r\n# :math:`SU(N-1)` transformation.\r\n#\r\n# :math:`SU(2)` is the \"base case\" of the recursion---we simply have the Haar measure\r\n# as expressed above.\r\n#\r\n# |\r\n#\r\n# .. figure:: /demonstrations/haar_measure/su2_haar.svg\r\n#    :align: center\r\n#    :width: 25%\r\n#\r\n# |\r\n#\r\n# Moving on up, we can write elements of :math:`SU(3)` as a sequence of three\r\n# :math:`SU(2)` transformations. The Haar measure :math:`d\\mu_3` then consists\r\n# of two copies of :math:`d\\mu_2`, with an extra term in between to take into\r\n# account the middle transformation.\r\n#\r\n# |\r\n#\r\n# .. figure:: /demonstrations/haar_measure/su3_haar.svg\r\n#    :align: center\r\n#    :width: 80%\r\n#\r\n# |\r\n#\r\n# For :math:`SU(4)` and upwards, the form changes slightly, but still follows\r\n# the pattern of two copies of :math:`d\\mu_{N-1}` with a term in between.\r\n#\r\n# |\r\n#\r\n# .. figure:: /demonstrations/haar_measure/su4_premerge.svg\r\n#    :align: center\r\n#    :width: 90%\r\n#\r\n# |\r\n#\r\n# For larger systems, however, the recursive composition allows for some of the\r\n# :math:`SU(2)` transformations on the lower modes to be grouped. We can take\r\n# advantage of this and aggregate some of the parameters:\r\n#\r\n# |\r\n#\r\n# .. figure:: /demonstrations/haar_measure/su4_triangle_merge.svg\r\n#    :align: center\r\n#    :width: 100%\r\n#\r\n# |\r\n#\r\n# This leads to one copy of :math:`d\\mu_{N-1}`, which we'll denote as\r\n# :math:`d\\mu_{N-1}^\\prime`, containing only a portion of the full set of terms\r\n# (as detailed in [#deGuise2018]_, this is called a *coset measure*).\r\n#\r\n# |\r\n#\r\n# .. figure:: /demonstrations/haar_measure/su4_haar.svg\r\n#    :align: center\r\n#    :width: 100%\r\n#\r\n# |\r\n#\r\n# Putting everything together, we have that\r\n#\r\n# .. math::\r\n#\r\n#    d\\mu_N = d\\mu_{N-1}^\\prime \\times \\sin \\theta_{N-1}\r\n#    \\sin^{2(N-2)}\\left(\\frac{\\theta_{N-1}}{2}\\right) d\\theta_{N-1} d\\omega_{N-1} \\times d\\mu_{N-1}\r\n#\r\n# The middle portion depends on the value of :math:`N`, and the parameters\r\n# :math:`\\theta_{N-1}` and :math:`\\omega_{N-1}` contained in the :math:`(N-1)`'th\r\n# :math:`SU(N)` transformation. This is thus a convenient, systematic way to\r\n# construct the :math:`N`-dimensional Haar measure for the unitary group. As a\r\n# final note, even though unitaries can be parametrized in different ways, the\r\n# underlying Haar measure is *unique*. This is a consequence of it being an\r\n# invariant measure, as will be shown later.\r\n#\r\n# Haar-random matrices from the :math:`QR` decomposition\r\n# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n#\r\n# Nice-looking math aside, sometimes you just need to generate a large number of\r\n# high-dimensional Haar-random matrices. It would be very cumbersome to sample\r\n# and keep track of the distributions of so many parameters; furthermore, the\r\n# measure above requires you to parametrize your operations in a fixed way.\r\n# There is a much quicker way to perform the sampling by taking a (slightly\r\n# modified) `QR decomposition\r\n# <https://en.wikipedia.org/wiki/QR_decomposition>`__ of complex-valued\r\n# matrices.  This algorithm is detailed in [#Mezzadri2006]_, and consists of the\r\n# following steps:\r\n#\r\n# 1. Generate an :math:`N \\times N` matrix :math:`Z` with complex numbers :math:`a+bi`\r\n#    where both :math:`a` and :math:`b` are normally distributed with mean 0 and variance 1\r\n#    (this is sampling from the distribution known as the *Ginibre ensemble*).\r\n# 2. Compute a QR decomposition :math:`Z = QR`.\r\n# 3. Compute the diagonal matrix :math:`\\Lambda = \\hbox{diag}(R_{ii}/|R_{ii}|)`.\r\n# 4. Compute :math:`Q^\\prime = Q \\Lambda`, which will be Haar-random.\r\n#\r\n#\r\n\r\nfrom numpy.linalg import qr\r\n\r\ndef qr_haar(N):\r\n    \"\"\"Generate a Haar-random matrix using the QR decomposition.\"\"\"\r\n    # Step 1\r\n    A, B = np.random.normal(size=(N, N)), np.random.normal(size=(N, N))\r\n    Z = A + 1j * B\r\n\r\n    # Step 2\r\n    Q, R = qr(Z)\r\n\r\n    # Step 3\r\n    Lambda = np.diag([R[i, i] / np.abs(R[i, i]) for i in range(N)])\r\n\r\n    # Step 4\r\n    return np.dot(Q, Lambda)\r\n\r\n######################################################################\r\n# Let's check that this method actually generates Haar-random unitaries\r\n# by trying it out for :math:`N=2` and plotting on the Bloch sphere.\r\n#\r\n\r\n@qml.qnode(dev)\r\ndef qr_haar_random_unitary():\r\n    qml.QubitUnitary(qr_haar(2), wires=0)\r\n    return qml.state()\r\n\r\nqr_haar_samples = [qr_haar_random_unitary() for _ in range(num_samples)]\r\nqr_haar_bloch_vectors = np.array([convert_to_bloch_vector(s) for s in qr_haar_samples])\r\nplot_bloch_sphere(qr_haar_bloch_vectors)\r\n\r\n######################################################################\r\n# As expected, we find our qubit states are distributed uniformly over the\r\n# sphere.  This particular method is what's implemented in packages like\r\n# ``scipy``'s `unitary_group\r\n# <https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.unitary_group.html>`__\r\n# function.\r\n#\r\n# Now, it's clear that this method works, but it is also important to\r\n# understand *why* it works.  Step 1 is fairly straightforward---the base of our\r\n# samples is a matrix full of complex values chosen from a typical\r\n# distribution. This isn't enough by itself, since unitary matrices also\r\n# have constraints---their rows and columns must be orthonormal.\r\n# These constraints are where step 2 comes in---the outcome of a generic\r\n# QR decomposition consists of an *orthonormal* matrix :math:`Q`, and and upper\r\n# triangular matrix :math:`R`. Since our original matrix was complex-valued, we end\r\n# up with a :math:`Q` that is in fact already unitary. But why not stop there? Why\r\n# do we then perform steps 3 and 4?\r\n#\r\n# Steps 3 and 4 are needed because, while the QR decomposition yields a unitary,\r\n# it is not a unitary that is properly Haar-random. In [#Mezzadri2006]_, it is\r\n# explained that a uniform distribution over unitary matrices should also yield\r\n# a uniform distribution over the *eigenvalues* of those matrices, i.e., every\r\n# eigenvalue should be equally likely. Just using the QR decomposition out of\r\n# the box produces an *uneven* distribution of eigenvalues of the unitaries!\r\n# This discrepancy stems from the fact that the QR decomposition is not unique.\r\n# We can take any unitary diagonal matrix :math:`\\Lambda`, and re-express the decomposition\r\n# as :math:`QR = Q\\Lambda \\Lambda^\\dagger R = Q^\\prime R^\\prime`. Step 3 removes this\r\n# redundancy by fixing a :math:`\\Lambda` that depends on :math:`R`, leading to a unique\r\n# value of :math:`Q^\\prime = Q \\Lambda`, and a uniform distribution of eigenvalues.\r\n#\r\n# .. admonition:: Try it!\r\n#\r\n#    Use the ``qr_haar`` function above to generate random unitaries and construct\r\n#    a distribution of their eigenvalues. Then, comment out the lines for steps 3 and\r\n#    4 and do the same---you'll find that the distribution is no longer uniform.\r\n#    Check out reference [#Mezzadri2006]_ for additional details and examples.\r\n\r\n######################################################################\r\n# Fun (and not-so-fun) facts\r\n# --------------------------\r\n#\r\n# We've now learned what the Haar measure is, and both an analytical and\r\n# numerical means of sampling quantum states and unitary operations uniformly at\r\n# random. The Haar measure also has many neat properties that play a role in\r\n# quantum computing.\r\n#\r\n# Invariance of the Haar measure\r\n# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n#\r\n# Earlier, we showed that the Haar measure is used when integrating functions over\r\n# the unitary group:\r\n#\r\n# .. math::\r\n#\r\n#    \\int_{V \\in U(N)} f(V) d\\mu_N(V).\r\n#\r\n# One of the defining features of the Haar measure is that it is both left and\r\n# right *invariant* under unitary transformations. That is,\r\n#\r\n# .. math::\r\n#\r\n#    \\int_{V \\in U(N)} f(\\color{red}{W}V) d\\mu_N(V) =  \\int_{V \\in U(N)} f(V\\color{red}{W}) d\\mu_N(V) =  \\int_{V \\in U(N)} f(V) d\\mu_N(V).\r\n#\r\n# This holds true for *any* other :math:`N\\times N` unitary :math:`W`! A\r\n# consequence of such invariance is that if :math:`V` is Haar-random, then so is\r\n# :math:`V^T,` :math:`V^\\dagger,` and any product of another unitary matrix and\r\n# :math:`V` (where the product may be taken on either side).\r\n#\r\n# Another consequence of this invariance has to do with the structure of the entries\r\n# themselves: they must all come from the same distribution. This is because the\r\n# measure remains invariant under permutations, since permutations are unitary---\r\n# the whole thing still has to be Haar random no matter how the entries are ordered,\r\n# so all distributions must be the same.  The specific distribution is complex\r\n# numbers :math:`a+bi` where both :math:`a` and :math:`b` has mean 0 and variance\r\n# :math:`1/N` [#Meckes2014]_ (so, much like Ginibre ensemble we used in the QR decomposition\r\n# above, but with a different variance and constraints due to orthonormality).\r\n#\r\n# Concentration of measure\r\n# ~~~~~~~~~~~~~~~~~~~~~~~~\r\n#\r\n# An unfortunate (although interesting) property of the Haar measure is that it\r\n# suffers from the phenomenon of `concentration of measure\r\n# <https://en.wikipedia.org/wiki/Concentration_of_measure>`__. Most of the\r\n# \"stuff\" in the space concentrates around a certain area, and this gets worse\r\n# as the size of the system increases. You can see the beginnings of by looking\r\n# at the sphere. For the 3-dimensional sphere, we saw graphically how there is\r\n# concentration around the equator, and how the measure takes that into account\r\n# with the additional factor of :math:`\\sin \\theta`. This property becomes\r\n# increasingly prominent for `higher-dimensional spheres\r\n# <https://en.wikipedia.org/wiki/N-sphere>`__.\r\n#\r\n# .. important::\r\n#\r\n#    The concentration described here is not referring to what we witnessed\r\n#    earlier on, when we sampled quantum states (points on the Bloch sphere)\r\n#    incorrectly and found that they clustered around the poles. However, that\r\n#    is not unrelated. Concentration of measure refers to where the measure\r\n#    itself is concentrated, and which parts of the space should be more heavily\r\n#    weighted. For the case of the sphere, it is the equatorial area, and when\r\n#    we didn't sample properly and take that concentration into account, we\r\n#    obtained an uneven distribution.\r\n#\r\n# Let's consider an :math:`N`-dimensional unit sphere. Points on the sphere, or\r\n# vectors in this space, are parametrized by :math:`N-1` real coordinates.\r\n# Suppose we have some function :math:`f` that maps points on that sphere to\r\n# real numbers. Sample a point :math:`x` on that sphere from the uniform\r\n# measure, and compute the value of :math:`f(x)`. How close do you think the\r\n# result will be to the mean value of the function, :math:`E[f]`, over the\r\n# entire sphere?\r\n#\r\n# A result called `Levy's lemma\r\n# <https://en.wikipedia.org/wiki/Concentration_of_measure#Concentration_on_the_sphere>`__\r\n# [#Gerken2013]_, [#Hayden2006]_ expresses how likely it is that :math:`f(x)` is a specific\r\n# distance away from the mean. It states that, for an :math:`x` selected\r\n# uniformly at random, the probability that :math:`f(x)` deviates from\r\n# :math:`E[f]` by some amount :math:`\\epsilon` is bounded by:\r\n#\r\n# .. math::\r\n#\r\n#    \\hbox{Pr}(|f(x) - E[f]| \\ge \\epsilon) \\leq 2 \\exp\\left[-\\frac{N\\epsilon^2}{9\\pi^3 \\eta^2}\\right].\r\n#\r\n# A constraint on the function :math:`f` is that it must be `Lipschitz\r\n# continuous <https://en.wikipedia.org/wiki/Lipschitz_continuity>`__, where\r\n# :math:`\\eta` is the *Lipschitz constant* of the function. The important aspect\r\n# here is the likelihood of deviating significantly from the mean by an amount\r\n# :math:`\\epsilon` decreases exponentially with :math:`\\epsilon.` Furthermore,\r\n# increasing the dimension :math:`N` also makes the deviation exponentially less\r\n# likely.\r\n#\r\n# Now, this result seems unrelated to quantum states---it concerns higher-\r\n# dimensional spheres. However, recall that a quantum state vector is a complex\r\n# vector whose squared values sum to 1, similar to vectors on a sphere. If you\r\n# \"unroll\" a quantum state vector of dimension :math:`N = 2^n` by stacking its\r\n# real and complex parts, you end with a vector of length :math:`2 \\cdot 2^{n}`\r\n# which ends up behaving just like a unit vector on the sphere in this\r\n# dimension. Given that measure concentrates on spheres, and quantum state\r\n# vectors can be converted to vectors on spheres, functions on random quantum\r\n# states will also demonstrate concentration.\r\n#\r\n# This is bad news! To do useful things in quantum computing, we need a lot of\r\n# qubits. But the more qubits we have, the more our randomly sampled states will\r\n# look the same (specifically, random states will concentrate around the\r\n# maximally entangled state [#Hayden2006]_). This has important consequences for\r\n# near-term algorithms (as detailed in the next section), and any algorithm that\r\n# involves uniform sampling of quantum states and operations.\r\n#\r\n# Haar measure and barren plateaus\r\n# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n#\r\n# Suppose you are venturing out to solve a new problem using an algorithm such\r\n# as the :doc:`variational quantum eigensolver </demos/tutorial_vqe>`. A\r\n# critical component of such methods is the choice of :doc:`variational ansatz\r\n# </glossary/circuit_ansatz>`. Having now learned a bit about the properties of\r\n# the Haar measure, you may think it would make sense to use this for the\r\n# parametrization. Variational ansaetze are, after all, parametrized quantum\r\n# circuits, so why not choose an ansatz that corresponds directly to a\r\n# parametrization for Haar-random unitaries?  The initial parameter selection\r\n# will give you a state in the Hilbert space uniformly at random. Then, since\r\n# this ansatz spans the entire Hilbert space, you're guaranteed to be able to\r\n# represent the target ground state with your ansatz, and it should be able to\r\n# find it with no issue ... right?\r\n#\r\n# Unfortunately, while such an ansatz is extremely *expressive* (i.e., it is\r\n# capable of representing any possible state), these ansaetze actually suffer\r\n# the most from the barren plateau problem [#McClean2018]_, [#Holmes2021]_.\r\n# :doc:`Barren plateaus </demos/tutorial_barren_plateaus>` are regions in the\r\n# cost landscape of a parametrized circuit where both the gradient and its\r\n# variance approach 0, leading the optimizer to get stuck in a local minimum.\r\n# This was explored recently in the work of [#Holmes2021]_, wherein closeness to\r\n# the Haar measure was actually used as a metric for expressivity. The closer\r\n# things are to the Haar measure, the more expressive they are, but they are\r\n# also more prone to exhibiting barren plateaus.\r\n#\r\n#\r\n# .. figure:: /demonstrations/haar_measure/holmes-costlandscapes.png\r\n#    :align: center\r\n#    :width: 50%\r\n#\r\n#    Image source: [#Holmes2021]_. A highly expressive ansatz that can access\r\n#    much of the space of possible unitaries (i.e., an ansatz capable of\r\n#    producing unitaries in something close to a Haar-random manner) is very\r\n#    likely to have flat cost landscapes and suffer from the barren plateau\r\n#    problem.\r\n#\r\n# It turns out that the types of ansaetze know as *hardware-efficient ansaetze*\r\n# also suffer from this problem if they are \"random enough\" (this notion will be\r\n# formalized in a future demo). It was shown in [#McClean2018]_ that this is a\r\n# consequence of the concentration of measure phenomenon described above. The\r\n# values of gradients and variances can be computed for classes of circuits on\r\n# average by integrating with respect to the Haar measure, and it is shown that\r\n# these values decrease exponentially in the number of qubits, and thus huge\r\n# swaths of the cost landscape are simply and fundamentally flat.\r\n#\r\n# Conclusion\r\n# ----------\r\n#\r\n# The Haar measure plays an important role in quantum computing---anywhere\r\n# you might be dealing with sampling random circuits, or averaging over\r\n# all possible unitary operations, you'll want to do so with respect\r\n# to the Haar measure.\r\n#\r\n# There are two important aspects of this that we have yet to touch upon,\r\n# however. The first is whether it is efficient to sample from the Haar measure---given\r\n# that the number of parameters to keep track of is exponential in the\r\n# number of qubits, certainly not. But a more interesting question is do we\r\n# *need* to always sample from the full Haar measure?  The answer to this is\r\n# \"no\" in a very interesting way. Depending on the task at hand, you may be able\r\n# to take a shortcut using something called a *unitary design*. In an upcoming\r\n# demo, we will explore the amazing world of unitary designs and their\r\n# applications!\r\n#\r\n# References\r\n# ----------\r\n#\r\n# .. [#NandC2000]\r\n#\r\n#     M. A. Nielsen, and I. L. Chuang (2000) \"Quantum Computation and Quantum Information\",\r\n#     Cambridge University Press.\r\n#\r\n# .. [#deGuise2018]\r\n#\r\n#     H. de Guise, O. Di Matteo, and L. L. Sánchez-Soto. (2018) \"Simple factorization\r\n#     of unitary transformations\", `Phys. Rev. A 97 022328\r\n#     <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.97.022328>`__.\r\n#     (`arXiv <https://arxiv.org/abs/1708.00735>`__)\r\n#\r\n# .. [#Clements2016]\r\n#\r\n#     W. R. Clements, P. C. Humphreys, B. J. Metcalf, W. S. Kolthammer, and\r\n#     I. A. Walmsley (2016) “Optimal design for universal multiport\r\n#     interferometers”, \\ `Optica 3, 1460–1465\r\n#     <https://www.osapublishing.org/optica/fulltext.cfm?uri=optica-3-12-1460&id=355743>`__.\r\n#     (`arXiv <https://arxiv.org/abs/1603.08788>`__)\r\n#\r\n# .. [#Reck1994]\r\n#\r\n#    M. Reck, A. Zeilinger, H. J. Bernstein, and P. Bertani (1994) “Experimental\r\n#    realization of any discrete unitary operator”, `Phys. Rev. Lett.73, 58–61\r\n#    <https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.73.58>`__.\r\n#\r\n# .. [#Mezzadri2006]\r\n#\r\n#     F. Mezzadri (2006) \"How to generate random matrices from the classical compact groups\".\r\n#     (`arXiv <https://arxiv.org/abs/math-ph/0609050>`__)\r\n#\r\n# .. [#Meckes2014]\r\n#\r\n#     E. Meckes (2019) `\"The Random Matrix Theory of the Classical Compact Groups\"\r\n#     <https://case.edu/artsci/math/esmeckes/Haar_book.pdf>`_, Cambridge University Press.\r\n#\r\n# .. [#Gerken2013]\r\n#\r\n#     M. Gerken (2013) \"Measure concentration: Levy's Lemma\"\r\n#     (`lecture notes <http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.679.2560>`__).\r\n#\r\n#\r\n# .. [#Hayden2006]\r\n#\r\n#     P. Hayden, D. W. Leung, and A. Winter (2006) \"Aspects of generic\r\n#     entanglement\", `Comm. Math. Phys. Vol. 265, No. 1, pp. 95-117\r\n#     <https://link.springer.com/article/10.1007%2Fs00220-006-1535-6>`__.\r\n#     (`arXiv <https://arxiv.org/abs/quant-ph/0407049>`__)\r\n#\r\n# .. [#McClean2018]\r\n#\r\n#     J. R. McClean, S. Boixo, V. N. Smelyanskiy, R. Babbush, and H. Neven\r\n#     (2018) \"Barren plateaus in quantum neural network training\r\n#     landscapes\", `Nature Communications, 9(1)\r\n#     <http://dx.doi.org/10.1038/s41467-018-07090-4>`__.\r\n#     (`arXiv <https://arxiv.org/abs/1803.11173>`__)\r\n#\r\n# .. [#Holmes2021]\r\n#\r\n#     Z. Holmes, K. Sharma, M. Cerezo, and P. J. Coles (2021) \"Connecting ansatz\r\n#     expressibility to gradient magnitudes and barren plateaus\". (`arXiv\r\n#     <https://arxiv.org/abs/2101.02138>`__)\r\n#\r\n#\r\n", "meta": {"hexsha": "bec5b914fccec24183f959b9741791910e23d08e", "size": 38364, "ext": "py", "lang": "Python", "max_stars_repo_path": "demonstrations/tutorial_haar_measure.py", "max_stars_repo_name": "jamesellis1999/qml", "max_stars_repo_head_hexsha": "33c9d66712b36861dc098f9c789ba2c3ab897fdb", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 216, "max_stars_repo_stars_event_min_datetime": "2020-08-01T03:18:37.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T06:17:52.000Z", "max_issues_repo_path": "demonstrations/tutorial_haar_measure.py", "max_issues_repo_name": "jamesellis1999/qml", "max_issues_repo_head_hexsha": "33c9d66712b36861dc098f9c789ba2c3ab897fdb", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 173, "max_issues_repo_issues_event_min_datetime": "2020-08-05T09:24:15.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T13:37:05.000Z", "max_forks_repo_path": "demonstrations/tutorial_haar_measure.py", "max_forks_repo_name": "jamesellis1999/qml", "max_forks_repo_head_hexsha": "33c9d66712b36861dc098f9c789ba2c3ab897fdb", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 66, "max_forks_repo_forks_event_min_datetime": "2020-08-01T05:02:45.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-02T19:34:54.000Z", "avg_line_length": 47.072392638, "max_line_length": 139, "alphanum_fraction": 0.6905171515, "include": true, "reason": "import numpy,from numpy,from scipy", "num_tokens": 10300, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO\n\n", "lm_q1_score": 0.35936415888237616, "lm_q2_score": 0.1755380800931169, "lm_q1q2_score": 0.06308209450449014}}
{"text": "#!usr/bin/env python3\nimport numba\nfrom numba.typed import List\n\n\n# JIT, Just-In-Time compiling, is a technology that has been used very\n# successfully in several dynamic languages to gain performance.\n# The idea behind Just-In-Time is that we collect information on the code at\n# run time and according to this information, we generate specific machine\n# code for these cases. If you're function runs only once, JIT will not help.\n# But in most cases, bottlenecks are in functions that are called many times.\n# Numba, this is a compiler kit called LLVM, under the hood, to generate\n# machine code for Python functions.\n# LLVM is an acronym that stands for low level virtual machine.\n# It also refers to a compiling technology called the LLVM project, which is a\n# collection of modular and reusable compiler and toolchain technologies.\n\n\ndef poly(coeffs, n):\n    \"\"\"Compute value of polynomial given coefficients\"\"\"\n    total = 0\n    for i, c in enumerate(coeffs):\n        total += c * n ** i\n    return total\n\n\n@numba.jit\ndef poly_j(coeffs, n):\n    \"\"\"Compute value of polynomial given coefficients - JIT\"\"\"\n    total = 0\n    for i, c in enumerate(coeffs):\n        total += c * n ** i\n    return total\n\n\nif __name__ == '__main__':\n    # previously we had coeffs = [4, 8, 15, 16, 23, 42] but we were getting\n    # a warning:\n    # http://numba.pydata.org/numba-doc/latest/reference/deprecation.html#deprecation-of-reflection-for-list-and-set-types\n    coeffs = List()\n    [coeffs.append(x) for x in [4, 8, 15, 16, 23, 42]]\n\n# In [7]: %run src/using_jit.py\n#\n# In [8]: poly(coeffs, 7)\n# Out[8]: 767400\n#\n# In [9]: poly_j(coeffs, 7)\n# Out[9]: 767400\n#\n# In [10]: %timeit poly(coeffs, 7)\n# 18.6 µs ± 2.08 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n#\n# In [11]: %timeit poly_j(coeffs, 7)\n# 1.67 µs ± 36.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n", "meta": {"hexsha": "89a270545cd974ee8e357bb99779dfca15e07024", "size": 1880, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/using_jit.py", "max_stars_repo_name": "ariannasg/optimizing-python", "max_stars_repo_head_hexsha": "e6c307dc694bc98c776faea1dbd7f420c2928f64", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/using_jit.py", "max_issues_repo_name": "ariannasg/optimizing-python", "max_issues_repo_head_hexsha": "e6c307dc694bc98c776faea1dbd7f420c2928f64", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/using_jit.py", "max_forks_repo_name": "ariannasg/optimizing-python", "max_forks_repo_head_hexsha": "e6c307dc694bc98c776faea1dbd7f420c2928f64", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.5714285714, "max_line_length": 122, "alphanum_fraction": 0.6893617021, "include": true, "reason": "import numba,from numba", "num_tokens": 539, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.12592275663455996, "lm_q1q2_score": 0.06296137831727998}}
{"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n# ---\n# jupyter:\n#   jupytext:\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.4'\n#       jupytext_version: 1.1.4\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# # s_stock_short_horizon [<img src=\"https://www.arpm.co/lab/icons/icon_permalink.png\" width=30 height=30 style=\"display: inline;\">](https://www.arpm.co/lab/redirect.php?code=s_stock_short_horizon&codeLang=Python)\n# For details, see [here](https://www.arpm.co/lab/redirect.php?permalink=ExerStockShort).\n\n# +\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.dates as mdates\nimport datetime as dt\nfrom pandas.plotting import register_matplotlib_converters\nregister_matplotlib_converters()\n\nfrom arpym.tools import add_logo\n# -\n\n# ## [Input parameters](https://www.arpm.co/lab/redirect.php?permalink=s_stock_short_horizon-parameters)\n\n# day, month and the year of the plotted value\nday = 2\nmonth = 9\nyear = 2015\n\n# ## [Step 0](https://www.arpm.co/lab/redirect.php?permalink=s_stock_short_horizon-implementation-step00): Load data\n\n# loading data from 2015-05-27 to 2015-12-07\npath = '../../../databases/global-databases/high-frequency/db_stock_NOK_intraday/'\ndf_nokia_stock = pd.read_csv(path + 'data.csv',\n                             header=0)\n# convert column 'date' from string to datetime64\ndf_nokia_stock['date'] = pd.to_datetime(df_nokia_stock.date, dayfirst=True)\n\n# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_stock_short_horizon-implementation-step01): Select the data to be plotted\n\nt_first = dt.datetime(year, month, day, 9, 30)  # starting time\nt_last = dt.datetime(year, month, day, 16, 0)  # ending time\n# select data\nv_stock = df_nokia_stock[(df_nokia_stock.date >= t_first) &\n                         (df_nokia_stock.date <= t_last)]\n\n# ## Plots\n\n# +\nplt.style.use('arpm')\n# extract values from dataframe\nt = v_stock.date.values\nv_t_stock = v_stock.price.values\n\nnumber_of_xticks = 6\ntick_array = np.linspace(0, t.shape[0]-1, number_of_xticks, dtype=int)\nmyFmt = mdates.DateFormatter('%H:%M:%S')\n\nfig = plt.figure()\nplt.plot_date(t, v_t_stock, '-')\nplt.gca().xaxis.set_major_formatter(myFmt)\nplt.xticks(t[tick_array])\nplt.xlabel('Time')\nplt.ylabel('Value')\nplt.title(f'NOKIA intraday value on {dt.date(year, month, day)}')\nadd_logo(fig)\n", "meta": {"hexsha": "a1a93a624d81fdd77757b02d007e64b495b462d4", "size": 2421, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/sources/s_stock_short_horizon.py", "max_stars_repo_name": "dpopadic/arpmRes", "max_stars_repo_head_hexsha": "ddcc4de713b46e3e9dcb77cc08c502ce4df54f76", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-04-10T13:24:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T08:20:42.000Z", "max_issues_repo_path": "scripts/sources/s_stock_short_horizon.py", "max_issues_repo_name": "dpopadic/arpmRes", "max_issues_repo_head_hexsha": "ddcc4de713b46e3e9dcb77cc08c502ce4df54f76", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scripts/sources/s_stock_short_horizon.py", "max_forks_repo_name": "dpopadic/arpmRes", "max_forks_repo_head_hexsha": "ddcc4de713b46e3e9dcb77cc08c502ce4df54f76", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2019-08-13T22:02:17.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-09T17:49:12.000Z", "avg_line_length": 31.8552631579, "max_line_length": 213, "alphanum_fraction": 0.7125154895, "include": true, "reason": "import numpy", "num_tokens": 681, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48438008427698437, "lm_q2_score": 0.12940272487671914, "lm_q1q2_score": 0.06268010278145664}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # 5 - Medium Level Example - Modeling Carports and Canopies + Sampling accross a Module!\n# \n# This journal shows how to model a carport or canopy ~ a fixed structure, usually at a high clearance from the ground, with more than one bifacial solar module in the same inclined-plane to create a \"shade\" for the cars/people below.\n# \n# We assume that bifacia_radiacne is already installed in yoru computer. This works for bifacial_radiance v.3 release.\n# \n# These journal outlines 4 useful uses of bifacial_radiance and some tricks: \n# \n# <ul>\n#     <li> Creating the modules in the canopy/carport </li>\n#     <li> Adding extra geometry for the pillars/posts supporting the carport/canopy </li>\n#     <li> Sampling the rear irradiance with more resolution (more sensors) </li>\n#     <li> and hacking the sensor position to obtain an irradiance map of rear-irradiance. </li>\n#     <li> Adding an object to simulate a car with a specific reflectivity. </li>\n# </ul>\n# \n# This is what we will create:\n# ![Carport Image We will create](../images_wiki/Carport.png)\n# \n# ### Steps:\n# \n# <ol>\n#     <li> <a href='#step1'> Setup of Variables through Making OCT Axis </a></li>\n#     <li> <a href='#step2'> Adding the pillars </a></li>\n#     <li> <a href='#step3'> Analysis of the collector width </a></li>\n#     <li> <a href='#step4'> Mapping the irradiance througout all the Carport </a></li>\n#     <li> <a href='#step5'> Adding a \"Car\" </a></li>\n# <ol>\n# \n\n# <a id='step1'></a>\n\n# ### 1. Setup of Variables through Making OCT Axis\n# \n# We've done this before a couple times, no new stuff here. \n# \n# The magic is that, for doing the carport we see in the figure, we are going to do a 4-up configuration of modules (**numpanels**), and we are going to repeat that 4-UP 7 times (**nMods**)\n\n# In[2]:\n\n\nfrom bifacial_radiance import *   \nimport numpy as np\n\n\n# In[4]:\n\n\nfrom pathlib import Path\ntestfolder = str(Path().resolve().parent.parent / 'bifacial_radiance' / 'TEMP')\n\ntimestamp = 4020 # Noon, June 17th. \nsimulationname = 'HotelCarport'\n\n# MakeModule Parameters\nmoduletype='PrismSolar'\nnumpanels = 4  # Carport will have 4 modules along the y direction (N-S since we are facing it to the south) .\nx = 0.95  \ny = 1.95\nxgap = 0.15 # Leaving 15 centimeters between modules on x direction\nygap = 0.10 # Leaving 10 centimeters between modules on y direction\nzgap = 0 # no gap to torquetube.\nsensorsy = 10*numpanels  # this will give 70 sensors per module.\n\n# Other default values:\n\n# TorqueTube Parameters\naxisofrotationTorqueTube=False\ntorqueTube = False\ncellLevelModule = False\n\n# SceneDict Parameters\ngcr = 0.33   # We are only doing 1 row so this doesn't matter\nalbedo = 0.28  #'concrete'     # ground albedo\nclearance_height = 4.3 # m  \nnMods = 7 # six modules length.\nnRows = 1  # only 1 row\n\nazimuth_ang=180 # Facing south\ntilt =20 # tilt. \n\n# Now let's run the example\n\ndemo = RadianceObj(simulationname,path = testfolder)  # Create a RadianceObj 'object'\ndemo.setGround(albedo) # input albedo number or material name like 'concrete'.  To see options, run this without any input.\nepwfile = demo.getEPW(40.0583,-74.4057) # NJ lat/lon 40.0583° N, 74.4057\nmetdata = demo.readEPW(epwfile) # read in the EPW weather data from above\ndemo.gendaylit(4020)  # Use this to simulate only one hour at a time. \n# This allows you to \"view\" the scene on RVU (see instructions below)\n# timestam 4020 : Noon, June 17th.\n#demo.genCumSky(demo.epwfile) # Use this instead of gendaylit to simulate the whole year\n\n# Making module with all the variables\nmoduleDict=demo.makeModule(name=moduletype,x=x,y=y,numpanels = numpanels, xgap=xgap, ygap=ygap)\n# create a scene with all the variables\nsceneDict = {'tilt':tilt,'pitch': round(gcr/moduleDict['sceney'],3),'clearance_height':clearance_height,'azimuth':azimuth_ang, 'module_type':moduletype, 'nMods': nMods, 'nRows': nRows}  \nscene = demo.makeScene(moduletype=moduletype, sceneDict=sceneDict) #makeScene creates a .rad file with 20 modules per row, 7 rows.\noctfile = demo.makeOct(demo.getfilelist())  # makeOct combines all of the ground, sky and object fil|es into a .oct file.\n\n\n# If you view the Oct file at this point, you should see the array of 7 modules, with 4 modules each along the collector widt.\n\n# <a id='step2'></a>\n\n# ### 2. Adding the pillars\n# \n# We will add 4 pillars at roughly the back and front corners of the structure. Some of the code below is to calculate the positions of where the pillars will be at.\n# \n# We are calculating the location with some math geometry\n\n# In[5]:\n\n\nxright= x*4\nxleft=  -xright\n\n#centerhubheight = (1.9*3+1.9/2)*np.sin(tilt*np.pi/180)\ny2nd = -(y*numpanels/2)*np.cos(tilt*np.pi/180) + (y)*np.cos(tilt*np.pi/180)\ny6th=  -(y*numpanels/2)*np.cos(tilt*np.pi/180) + (y*numpanels)*np.cos(tilt*np.pi/180)\nz2nd = (y*np.sin(tilt*np.pi/180))+clearance_height\nz6th =  (y*numpanels)*np.sin(tilt*np.pi/180)+clearance_height\n\nname='Post1'\ntext='! genbox black cuteBox 0.5 0.5 {} | xform -t -0.25 -0.25 0 -t {} {} 0'.format(z2nd, xleft, y2nd)\nprint (text)\ncustomObject = demo.makeCustomObject(name,text)\ndemo.appendtoScene(radfile=scene.radfiles, customObject=customObject, text=\"!xform -rz 0\")\n\nname='Post2'\ntext='! genbox black cuteBox 0.5 0.5 {} | xform -t -0.25 -0.25 0 -t {} {} 0'.format(z2nd, xright, y2nd)\ncustomObject = demo.makeCustomObject(name,text)\ndemo.appendtoScene(scene.radfiles, customObject, '!xform -rz 0')\n\nname='Post3'\ntext='! genbox black cuteBox 0.5 0.5 {} | xform -t -0.25 -0.25 0 -t {} {} 0'.format(z6th, xright, y6th)\ncustomObject = demo.makeCustomObject(name,text)\ndemo.appendtoScene(scene.radfiles, customObject, '!xform -rz 0')\n\nname='Post4'\ntext='! genbox black cuteBox 0.5 0.5 {} | xform -t -0.25 -0.25 0 -t {} {} 0'.format(z6th, xleft, y6th)\ncustomObject = demo.makeCustomObject(name,text)\ndemo.appendtoScene(scene.radfiles, customObject, '!xform -rz 0')\n\noctfile = demo.makeOct(demo.getfilelist())  # makeOct combines all of the ground, sky and object files into a .oct file.\n\n\n# ### View the geometry with the posts on :\n# \n# ## rvu -vf views\\front.vp -e .01 -pe 0.4 -vp 3.5 -20 22 HotelCarport.oct\n# \n# -pe sets the exposure levels, and -vp sets the view point so the carport is centered (at least on my screen. you can play with the values). It should look like this:\n# \n# ![Carpport with posts](../images_wiki/Carport.png)\n# \n# The post should be coindient with the corners of the array on the high-end of the carport, and on the low end of the carport they should be between the lowest module and the next one. Cute! \n# \n# \n\n# <a id='step3'></a>\n# \n\n# ### 3. Analysis of the collector width\n# \n# Now let's do some analysis along the slope of the modules. Each result file will contain irradiance for the 4 modules that make up the slope of the carport. You can select which \"module\" along the row you sample too.\n# \n# We are also increasign the number of points sampled accross the collector width, with the  variable **sensorsy** passed to **moduleanalysis**\n\n# In[4]:\n\n\nanalysis = AnalysisObj(octfile, demo.name)  # return an analysis object including the scan dimensions for back irradiance\nmodWanted = 1\nrowWanted = 1\nfrontscan, backscan = analysis.moduleAnalysis(scene, modWanted=modWanted, rowWanted=rowWanted, sensorsy=sensorsy)\n\nanalysis.analysis(octfile, simulationname+\"Mod1\", frontscan, backscan)  # compare the back vs front irradiance  \nprint('Annual bifacial ratio average:  %0.3f' %( sum(analysis.Wm2Back) / sum(analysis.Wm2Front) ) )\nprint(\"\")\n\n\n# This is the module analysis and an image of the results file\n# ![This is the module analysed.](../images_wiki/Carport_analysis.PNG)\n# \n# You can repeat the analysis for any other module in the row:\n# \n# <div class=\"alert alert-warning\">\n# Notice we are passing a CUSTOM simulation name so the results are generated in separate csv files.\n# </div>\n# \n\n# In[5]:\n\n\nmodWanted = 2\nrowWanted = 1\nfrontscan, backscan = analysis.moduleAnalysis(scene, modWanted=modWanted, rowWanted=rowWanted, sensorsy=sensorsy)\n\nanalysis.analysis(octfile, simulationname+\"Mod2\", frontscan, backscan)  # compare the back vs front irradiance  \nprint('Annual bifacial ratio average:  %0.3f' %( sum(analysis.Wm2Back) / sum(analysis.Wm2Front) ) )\n\n\nmodWanted = 3\nrowWanted = 1\nfrontscan, backscan = analysis.moduleAnalysis(scene, modWanted=modWanted, rowWanted=rowWanted, sensorsy=sensorsy)\n        \nanalysis.analysis(octfile, simulationname+\"Mod3\", frontscan, backscan)  # compare the back vs front irradiance  \nprint('Annual bifacial ratio average:  %0.3f' %( sum(analysis.Wm2Back) / sum(analysis.Wm2Front) ) )\n\n\n# <a id='step4'></a>\n\n# ### 4. Mapping the irradiance througout all the Carport (\"Hack\" the sensors) \n# \n# You can \"hack\" the sensors starting locations to obtain an irradinace distribution map. This is easier when the modules are facing South, or East/West. Below is an example, you'll have to repeat over all the modules/ all the surface area with as much resolution as you have patience to see edge-effects.\n\n# In[6]:\n\n\n# HACK Frontscan and Backscan\nfrontscan['xstart']=-1.2\n        \nanalysis.analysis(octfile, simulationname+\"Mod3_point2\", frontscan, backscan)  # compare the back vs front irradiance  \nprint('Annual bifacial ratio average:  %0.3f' %( sum(analysis.Wm2Back) / sum(analysis.Wm2Front) ) )\n\n\n# <div class=\"alert alert-warning\">\n# The printed Annual bifacial ratio does not include cleaning of the sensors for the material. Some of the sensros might fall in the spacing between the modules (ygaps) or in the structures added, torquetubes, etc. For a real bifacial ratio gain, use the load and clean functions in load.py. \n# \n# (This process might be automated in a future release TBD)\n# </div>\n# \n# \n\n# <a id='step5'></a>\n\n# ### 5. Adding a \"Car\"\n# \n# Add a surface (just like we added the pillars) with a specific reflectivity to represent a car. If you are doing hourly simulation you can compare how much the irradiance increases with and without the car, and if you keep track of your parking lot comings/goings this could make an interesting toy-problem: how much are your employees contributing to your rear irradiance production? \n\n# In[7]:\n\n\nname='Car_1'\ncarpositionx=-2\ncarpositiony=-1\ntext='! genbox white_EPDM HondaFit 1.6 4.5 1.5 | xform -t -0.8 -2.25 0 -t {} {} 0'.format(carpositionx, carpositiony)\ncustomObject = demo.makeCustomObject(name,text)\ndemo.appendtoScene(scene.radfiles, customObject, '!xform -rz 0')\n\noctfile = demo.makeOct(demo.getfilelist())  # makeOct combines all of the ground, sky and object files into a .oct file.\n\n\n# Viewing with:\n# ## rvu -vf views\\front.vp -e .01 -pe 0.019 -vp 1.5 -14 15 HotelCarport.oct\n# \n# \n# ![Behold the Honda-fit sized cube](../images_wiki/Carport_with_car.PNG)\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "c188f421517a5255e33af4447b96764fb474b74b", "size": 10743, "ext": "py", "lang": "Python", "max_stars_repo_path": "docs/tutorials/5 - Medium Level Example - Bifacial Carports and Canopies + sampling across a module!.py", "max_stars_repo_name": "tjcoathu/bifacial_radiance", "max_stars_repo_head_hexsha": "6e22bf6214696c5994738284b0ae4499c5ca2c05", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 55, "max_stars_repo_stars_event_min_datetime": "2018-04-16T16:14:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T09:57:23.000Z", "max_issues_repo_path": "docs/tutorials/5 - Medium Level Example - Bifacial Carports and Canopies + sampling across a module!.py", "max_issues_repo_name": "tjcoathu/bifacial_radiance", "max_issues_repo_head_hexsha": "6e22bf6214696c5994738284b0ae4499c5ca2c05", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 350, "max_issues_repo_issues_event_min_datetime": "2018-02-15T10:51:28.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-28T21:18:08.000Z", "max_forks_repo_path": "docs/tutorials/5 - Medium Level Example - Bifacial Carports and Canopies + sampling across a module!.py", "max_forks_repo_name": "tjcoathu/bifacial_radiance", "max_forks_repo_head_hexsha": "6e22bf6214696c5994738284b0ae4499c5ca2c05", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 39, "max_forks_repo_forks_event_min_datetime": "2018-09-30T15:12:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-28T09:57:43.000Z", "avg_line_length": 40.2359550562, "max_line_length": 387, "alphanum_fraction": 0.7218654007, "include": true, "reason": "import numpy", "num_tokens": 3189, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4111108548019597, "lm_q2_score": 0.15203223585907102, "lm_q1q2_score": 0.06250210244147583}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.5'\n#       jupytext_version: 1.13.8\n#   kernelspec:\n#     display_name: Python 3 (ipykernel)\n#     language: python\n#     name: python3\n# ---\n\n# # Raster-vector interactions {#raster-vector}\n#\n# ## Prerequisites\n\n#| echo: false\nimport pandas as pd\nimport matplotlib.pyplot as plt\npd.options.display.max_rows = 6\npd.options.display.max_columns = 6\npd.options.display.max_colwidth = 35\nplt.rcParams[\"figure.figsize\"] = (5, 5)\n\n# Let's import the required packages:\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport geopandas as gpd\nimport rasterio\nimport rasterio.mask\nfrom rasterio.plot import show\n\n# and load the sample data:\n\nsrc_srtm = rasterio.open(\"data/srtm.tif\")\nzion = gpd.read_file(\"data/zion.gpkg\")\nzion_points = gpd.read_file(\"data/zion_points.gpkg\")\n\n# ## Introduction\n#\n# ## Raster cropping\n#\n# Many geographic data projects involve integrating data from many different sources, such as remote sensing images (rasters) and administrative boundaries (vectors). Often the extent of input raster datasets is larger than the area of interest. In this case raster **cropping** and **masking** are useful for unifying the spatial extent of input data. Both operations reduce object memory use and associated computational resources for subsequent analysis steps, and may be a necessary preprocessing step before creating attractive maps involving raster data.\n#\n# We will use two objects to illustrate raster cropping:\n#\n# * The `srtm.tif` raster representing elevation (meters above sea level) in south-western Utah\n# * The `zion.gpkg` vector layer representing the Zion National Park\n#\n# Both target and cropping objects must have the same projection. The following reprojects the vector layer `zion` into the CRS of the raster `src_srtm`:\n\nzion = zion.to_crs(src_srtm.crs)\n\n# To mask the image, i.e., convert all pixels which do not intersect with the `zion` polygon to \"No Data\", we use the `rasterio.mask.mask` function as follows:\n\nout_image_mask, out_transform_mask = rasterio.mask.mask(\n    src_srtm, \n    zion[\"geometry\"], \n    crop=False, \n    nodata=9999\n)\n\n# Note that we need to specify a \"No Data\" value in agreement with the raster data type. Since `srtm.tif` is of type `uint16`, we choose `9999` (a positive integer that is guaranteed not to occur in the raster). \n#\n# The result is the `out_image` array with the masked values: \n\nout_image_mask\n\n# and the new `out_transform`:\n\nout_transform_mask\n\n# Note that masking (without cropping!) does not modify the raster spatial configuration. Therefore, the new transform is identical to the original:\n\nsrc_srtm.transform\n\n# Unfortunately, the `out_image` and `out_transform` object do not contain any information indicating that `9999` represents \"No Data\". To associate the information with the raster, we must write it to file along with the corresponding metadata. For example, to write the cropped raster to file, we need to modify the \"No Data\" setting in the metadata:\n\nout_meta = src_srtm.meta\nout_meta.update(nodata=9999)\nout_meta\n\n# Then we can write the cropped raster to file:\n\nnew_dataset = rasterio.open(\"output/srtm_masked.tif\", \"w\", **out_meta)\nnew_dataset.write(out_image_mask)\nnew_dataset.close()\n\n# Now we can re-import the raster:\n\nsrc_srtm_mask = rasterio.open(\"output/srtm_masked.tif\")\n\n# The `.meta` property contains the `nodata` entry. Now, any relevant operation (such as plotting) will take \"No Data\" into account:\n\nsrc_srtm_mask.meta\n\n# Cropping means reducing the raster extent to the extent of the vector layer:\n#\n# * To crop *and* mask, we can use the same in `rasterio.mask.mask` expression shown above for masking, just setting `crop=True` instead of `crop=False`. \n# * To just crop, *without* masking, we can derive the extent polygon and then crop using it.\n#\n# For example, here is how we can obtain the extent polygon of `zion`, as a `shapely` geometry object:\n\nbb = zion.unary_union.envelope\nbb\n\n# The extent can now be used for masking. Here, we are also using the `all_touched=True` option so that pixels partially overlapping with the extent are included:\n\nout_image_crop, out_transform_crop = rasterio.mask.mask(\n    src_srtm, \n    [bb], \n    crop=True, \n    all_touched=True, \n    nodata=9999\n)\n\n# Figure ... shows the original raster, and the cropped and masked results.\n\nfig, axes = plt.subplots(ncols=3, figsize=(9,5))\nshow(src_srtm, ax=axes[0])\nzion.plot(ax=axes[0], color=\"none\", edgecolor=\"black\")\nshow(src_srtm_mask, ax=axes[1])\nzion.plot(ax=axes[1], color=\"none\", edgecolor=\"black\")\nshow(out_image_crop, transform=out_transform_crop, ax=axes[2])\nzion.plot(ax=axes[2], color=\"none\", edgecolor=\"black\")\naxes[0].set_title(\"Original\")\naxes[1].set_title(\"Mask\")\naxes[2].set_title(\"Crop\");\n\n# ## Raster extraction\n#\n# From points...\n#\n# From line...\n#\n# From polygon (srtm)...\n#\n# From polygon (nlcd)...\n#\n# ## Rasterization\n#\n# ...\n#\n# ## Spatial vectorization\n#\n# Spatial vectorization is the counterpart of rasterization (Section ...), but in the opposite direction. It involves converting spatially continuous raster data into spatially discrete vector data such as points, lines or polygons.\n#\n# There are three standard methods to convert a raster to a vector layer:\n#\n# * Raster to polygons\n# * Raster to points\n# * Raster to contours\n#\n# The most straightforward form of vectorization is the first one, converting raster cells to polygons, where each pixel is represented by a rectangular polygon. The second method, raster to points, has the additional step of calculating polygon centroids. The third method, raster to contours, is somewhat unrelated. Let us demonstrate the three in the given order.\n\nsrc = rasterio.open(\"data/grain.tif\")\n\n# To polygons... ...\n#\n#\n# FIGURE 6.9: Illustration of vectorization of raster (left) into polygons (dissolve = FALSE; center) and aggregated polygons (dissolve = TRUE; right). \n\nsrc = rasterio.open(\"data/elev.tif\")\n\n# To points...\n\nsrc = rasterio.open(\"data/elev.tif\")\n\n# To contours...\n#\n# ...\n#\n# Another common type of spatial vectorization is the creation of contour lines representing lines of continuous height or temperatures (isotherms) for example. We will use a real-world digital elevation model (DEM) because the artificial raster elev produces parallel lines (task for the reader: verify this and explain why this happens). Contour lines can be created with the terra function as.contour(), which is itself a wrapper around filled.contour(), as demonstrated below (not shown):\n#\n# Contours can also be added to existing plots with functions such as contour(), rasterVis::contourplot() or tmap::tm_iso(). As illustrated in Figure 6.8, isolines can be labelled.\n#\n# The final type of vectorization involves conversion of rasters to polygons. This can be done with terra::as.polygons(), which converts each raster cell into a polygon consisting of five coordinates, all of which are stored in memory (explaining why rasters are often fast compared with vectors!).\n#\n# This is illustrated below by converting the grain object into polygons and subsequently dissolving borders between polygons with the same attribute values (also see the dissolve argument in as.polygons()).\n#\n#\n#\n# ## Exercises\n#\n", "meta": {"hexsha": "197aa6c8d966d2d44b8aadbb59d2d2cdc6b66faa", "size": 7318, "ext": "py", "lang": "Python", "max_stars_repo_path": "code/chapters/06-raster-vector.py", "max_stars_repo_name": "geocompr/pytest", "max_stars_repo_head_hexsha": "fea416c99ddd47961ae36c3f8cfecfaa792eb778", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-02-17T13:32:58.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-17T13:32:58.000Z", "max_issues_repo_path": "code/chapters/06-raster-vector.py", "max_issues_repo_name": "geocompr/pytest", "max_issues_repo_head_hexsha": "fea416c99ddd47961ae36c3f8cfecfaa792eb778", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2022-01-13T21:20:06.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-17T19:45:31.000Z", "max_forks_repo_path": "code/chapters/06-raster-vector.py", "max_forks_repo_name": "anitagraser/py", "max_forks_repo_head_hexsha": "84f4102b96380a3acbe533ed4820427676ba226e", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-02-17T08:24:23.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-17T08:24:23.000Z", "avg_line_length": 38.9255319149, "max_line_length": 560, "alphanum_fraction": 0.7506149221, "include": true, "reason": "import numpy", "num_tokens": 1778, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.12421302132013365, "lm_q1q2_score": 0.062106510660066824}}
{"text": "#!/usr/bin/python\n\n''' \nThis is assignment 3, group submission by : \n    Student Name : Ravi Mishra Student ID: 21249928\n    Student Name : Prasad Deshpande Student ID: 21249530 \n    \n    Link to Github Repository : https://github.com/ravi3990/ARC.git\n    \n    \n\n'''\n\n\nimport os, sys\nimport json\nimport numpy as np\nimport re\nimport math\n\n### YOUR CODE HERE: write at least three functions which solve\n### specific tasks by transforming the input x and returning the\n### result. Name them according to the task ID as in the three\n### examples below. Delete the three examples. The tasks you choose\n### must be in the data/training directory, not data/evaluation.\n\n'''\nsolve_d4a91cb9: \n\nDifficulty Level according to us : Easy to Medium\n\nLogic :\n\nThe basic logic for solving this problem through the naked eye and to a layman \nperson would be get the coordinates of the two colours ie sky blue and red.The \nvalues for these in our list is 2 and 8.And then connect the 2 points throug \nit's row and column by two lines of yellows till it intersects.\n\nWe used the numpy where function to find the coordinates of these points.The main \nproblem in solving this issue was to find out in what direction the line has to be plotted.\nFor this we used the if else to determine if blue has higher column value or red.\nBased on that we update the corresponding values in the given row and column to 4.\n\nBasic python and numpy used.Was able to solve all inputs and outputs in the json \nfile successfully.\n\n    \n'''\n\ndef solve_d4a91cb9(x):\n    #Changing to Numpy array in case the input is a list\n    b=np.array(x)\n   #Getting the position of 8 and 2 in the array    \n    eight_pos=np.where(b==8)[0][0],np.where(b==8)[1][0]\n    two_pos=np.where(b==2)[0][0],np.where(b==2)[1][0]\n    #Changing the column values to 4 \n    if eight_pos[0]<two_pos[0]:\n        for i in range (eight_pos[0]+1,two_pos[0]+1):\n            b[i][eight_pos[1]]=4\n    elif eight_pos[0]>two_pos[0]:\n        for i in range (two_pos[0],eight_pos[0]):\n            b[i][eight_pos[1]]=4\n    \n    #Changing the row  values to 4\n    if eight_pos[1]<two_pos[1]:\n        for i in range (eight_pos[1]+1,two_pos[1]):\n            b[two_pos[0]][i]=4\n    elif eight_pos[1]>two_pos[1]:\n        for i in range (two_pos[1]+1,eight_pos[1]+1):\n            b[two_pos[0]][i]=4\n    return b\n\n'''\nsolve_f5b8619d: \n\nDifficulty Level according to us : Easy\n\nLogic :\n\nOn a first look it looked a little difficult to us.However we could quickly understand \nthat it is a mirror effect after some basic changes to the inital array.\nIn the initial array we have to identify the columns where the value is non zero.\nWe have to change the value of all the rows for that column without touching the original \nvalues to 8.Once it is completed we have to mirror the array along the horizontal \naxis once and then the vertical axis once.This can be done interchangeably as well.\n\nBasic python and numpy has been used.\n\nAll the test inputs and outputs were successfully validated and passed.\n    \n'''\n\n\ndef solve_f5b8619d(x):\n    new_arr=np.array(x)\n    #Getting the columns where the value is non zero and changing rest of the column values to 8\n    for mn in np.where(new_arr!=0)[1]:\n        for i in range(new_arr.shape[1]):\n            if new_arr[i][mn]==0:\n                new_arr[i][mn]=8\n     #Mirroring the array horizontally and vertically           \n    new_arr=np.concatenate((new_arr,new_arr),axis=0)\n    new_arr=np.concatenate((new_arr,new_arr),axis=1)\n    return new_arr\n\n'''\nsolve_0a938d79: \n    \nDifficulty Level according to us : Easy \n\nWe found Task 0a938d79 simple to understand and implement. Looking at task demonstration \nwe can see alternate coloured line pattern repeats until end of array. If number of rows are \nmore than the columns then line patterns are repeated until last row. If the number of \ncolumns are more than the rows then the line patterns are repeated until end of last column. \nCount for intermediate black rows are dependent on number of columns/rows between given \ntwo colour cells. \n\nSolver function checked shape of array, colours of non-black locations and loop through\nthe rows/columns until max number of rows/columns reached. Coloured locations/cells are\nused as reference to paint the location to create the line in X or Y axis and new array\nreturn after transformation. \n\nAll training and test grids solved correctly. \n    \n'''\n\ndef solve_0a938d79(x):\n    '''empty list to collect coloured cells'''\n    non_zero = []\n    \n    ''' copy input array'''\n    new_arr=np.array(x)\n    \n    ''' get number of rows are colums with shape'''\n    num_rows, num_cols = new_arr.shape \n    \n    '''find the non-zero coordinates '''\n    non_zero = np.nonzero(new_arr)\n    \n    '''find the colour at non-zero coordinates '''\n    colour_1 = new_arr[non_zero[0][0], non_zero[1][0]]\n    colour_2 = new_arr[non_zero[0][1], non_zero[1][1]]\n\n    '''if number of columns are greater than rows then patterns need to be \n    formed in x-axis else in y-axis'''\n        \n    if(num_cols > num_rows):\n        black_mid_segments = abs(non_zero[1][1] - non_zero[1][0]) \n        while((non_zero[1][0] or non_zero[1][1]) < num_cols):\n            '''fill the colour at non-zero column''' \n            for i in range(num_rows):\n                if(non_zero[1][0] < num_cols):\n                    new_arr[i,non_zero[1][0]] = colour_1\n                if(non_zero[1][1] < num_cols):\n                    new_arr[i,non_zero[1][1]] = colour_2     \n            '''increment coloumn index based number of empty col. in pattern'''\n            non_zero[1][0] += (black_mid_segments*2)\n            non_zero[1][1] += (black_mid_segments*2)\n    else:\n        black_mid_segments = abs(non_zero[0][0] - non_zero[0][1]) \n        while((non_zero[0][0] or non_zero[0][1]) < num_rows):\n            '''fill the colour at non-zero rows''' \n            for i in range(num_cols):\n                if(non_zero[0][0] < num_rows):\n                    new_arr[non_zero[0][0], i] = colour_1\n                if(non_zero[0][1] < num_rows):\n                    new_arr[non_zero[0][1], i] = colour_2     \n            '''increment row index based number of empty col. in pattern'''\n            non_zero[0][0] += (black_mid_segments*2)\n            non_zero[0][1] += (black_mid_segments*2)\n    \n    ''' return the modified array''' \n    return new_arr\n\n'''\nsolve_1a07d186(x)\n\nDifficulty Level according to us : Medium to difficult \n\nWe found Task 1a07d186 medium to be difficult. On the first look, task seems easy \ni.e. just moving the coloured cells adjacent to respective lines. But it is also important to \nidentify line as object, move coloured cells in right direction and to remove other \ncoloured cells which doesn’t have coloured line present. The same logic then needs to be \ndefined for vertical and horizontal lines (single/multiple).\n\nWe decided to implement the solver function with basic logic and with less use of \nlibrary APIs. Numpy is used only where necessary, so the code looks big. It identified \ncolour in array and marked the coordinates. Then identified the line object with traversing \nin X/Y axis from edge to edge to confirm the line position. Once all these information \nis available, then look for nearest line coordinate for coloured cell and paint next \nlocation in same row/column. The original colour location is then overwritten with black. \nIn case of cells with colours other than line colour, the location is overwritten with black.  \n\nAll training and test grids solved correctly. \n\n'''\n\ndef solve_1a07d186(x):\n    \n    ''' copy input array'''\n    new_arr=np.array(x)\n    \n    ''' get number of rows are colums with shape'''\n    num_rows, num_cols = new_arr.shape \n    \n    '''find the non-zero coordinates '''\n    non_zero = np.nonzero(new_arr)\n\n    ''' index for checking all coordinates around the colour'''\n    Dy = [0, -1, 0, 1]\n    Dx = [1, 0, -1, 0]\n    \n    ''' empty lists to log if Hlines or Vlines found in image'''\n    H_line = []\n    V_line = []\n    \n   \n    ''' loop to check colour around all identified colour co-ordinates '''\n    for x, y  in zip(non_zero[0],non_zero[1]):\n        colour = new_arr[x][y]\n        \n        for dy, dx in zip(Dy, Dx):\n            ''' if same colour found then move either x or y axis to find if it is a line'''\n            x_, y_ = x+dx, y+dy\n            \n            ''' loop through number of cols or rows to find lines and log into list '''\n            if(x_ < num_rows and y_ < num_cols):\n                if(colour == new_arr[x_][y_]):\n                    if(abs(x_ - x)):\n                        #vertical line \n                        for k in range(num_rows):\n                            if(colour == new_arr[k][y]):\n                                V_line.append(y) \n                                v_line_flag = True\n                \n                    if (abs(y_-y)):\n                        #horizontal line \n                        for k in range(num_cols):\n                            if(colour == new_arr[x][k]):\n                                H_line.append(x)\n                                v_line_flag = False\n    \n    ''' consider only unique items to give exact number of lines and their one \n    coordinates location. Other location can be assumed zero as it is a line'''  \n    H_line = np.unique(H_line)\n    V_line = np.unique(V_line)\n    \n    ''' loop through all coloured cellls to either associate with line or if \n    not then make it zero'''\n    for x, y  in zip(non_zero[0],non_zero[1]):\n        if(v_line_flag == True):\n            ''' if y is not in Vline then proceed '''\n            if(y not in V_line):\n                colour_flag = False    \n                colour = new_arr[x][y]\n                \n                for i in V_line:\n                    if(colour == new_arr[0, i]):\n                        if(i < y):\n                            new_arr[x,i+1] = colour\n                        else:\n                            new_arr[x,i-1] = colour\n                        \n                        new_arr[x][y] = 0\n                        colour_flag = True\n                ''' if colour cell is not associated with line colour then \n                make it zero '''        \n                if(colour_flag == False ): \n                    new_arr[x][y] = 0\n            \n            \n        if(v_line_flag == False):\n            '''if x is not in Hline then proceed '''\n            if(x not in H_line):\n                colour_flag = False    \n                colour = new_arr[x][y]\n    \n                for i in H_line:\n                    if(colour == new_arr[i, 0]):\n                        if(i < x):\n                            new_arr[i+1, y] = colour\n                        else:\n                            new_arr[i-1, y] = colour\n                        \n                        new_arr[x][y] = 0\n                        colour_flag = True    \n                ''' if colour cell is not associated with line colour then \n                make it zero '''        \n                if(colour_flag == False ): \n                    new_arr[x][y] = 0\n                        \n               \n                    \n    ''' return the modified array''' \n    return new_arr\n\n'''\ndef solve_00d62c1b(x)\n\nDifficulty Level according to us : Medium to difficult \n\nWe found task 00d62c1b medium to be difficult. The challenge was in finding the enclosed \nshape to fill the space with yellow colour. The logic which is applied here is same \nas previous task 1a07d186, instead of lines, here is to identify the space enclosed \nwith green colour. \n\nSame logic of x, y location +/-1 for checking all coordinates around the coloured \ncell used. Code optimized with the use of list as queue and multiple conditions in loops. \n‘Searched’ array created with padding of rows and columns. Based on search the true/False \nmarked and resultant used for filling yellow colour. \nThe in-line comments give more details of logic. \n\nAll training and test grids solved correctly.\n\n'''\n\ndef solve_00d62c1b(x):\n    \n    ''' copy input array'''\n    new_arr=np.array(x)\n    \n    ''' get number of rows are colums with shape'''\n    num_rows, num_cols = new_arr.shape \n \n    green = 3 \n    yellow = 4\n    \n    ''' index for checking all coordinates around the colour'''\n    Dy = [0, -1, 0, 1]\n    Dx = [1, 0, -1, 0]\n    \n    '''\n    https://numpy.org/doc/stable/reference/generated/numpy.pad.html\n    \n    ((1,1),(1,1)) -Number of values padded to the edges of each axis. ((before_1, after_1)\n    pads with 'Constant' value of zero [False]                                                               \n    \n    '''\n    \n    arr_padded = np.pad(new_arr, ((1,1),(1,1)), \"constant\", constant_values=0)\n    \n    ''' \n    input array padded on x and y axis at the edge i.e. num_col and num_rows \n    increased by 2 and created searched array with default False in each element''' \n    search_empty_sq = np.zeros(arr_padded.shape, dtype=bool)\n    search_empty_sq[0, 0] = True\n    \n    queue = [(0, 0)]\n    while queue:\n        ''' take each element/cell from matrix'''\n        j, i = queue.pop()\n        \n        ''' loop for near by coordinates in x, y axis '''\n        for dy, dx in zip(Dy, Dx):\n            y_, x_ = j+dy, i+dx\n            \n            if not 0 <= y_ < num_rows+2 or not 0 <= x_ < num_cols+2:\n                ''' skip the next logic for edge elements/cells'''\n                continue\n            ''' in case of identical elements change value at searched to True \n                else maintain the value at False. False indicates yellow colour \n                to add \n            '''\n            if not search_empty_sq[y_][x_] and arr_padded[y_][x_]==0:\n                '''add to queue for next operation '''\n                queue.append((y_, x_))\n                search_empty_sq[y_, x_] = True\n    \n    '''remove the padding'''\n    res = search_empty_sq[1:-1, 1:-1]\n    \n    ''' check the green and keep it as it is'''\n    res |= new_arr==green\n    \n    ''' invert the searched results and fill true with yellow '''\n    new_arr[~res] = yellow \n   \n    ''' return the modified array''' \n    return new_arr\n\n'''\ndef solve_d0f5fe59(x)\n\nDifficulty level according to us : Medium\n\nLogic:\nThe idea behind solving this problem was to get the number of islands within a \nparticular array.This was done through a depth first search.Once a particulat \nisland is visited it is not counted twice.For this we created an internal functions \ncalled dfs.\n\n\nAfter iterating through the entire array we found the number of islands.We then \ncreated a numpy zero array with the same dimensions as the number of islands.\nWe then update the diagonal of the array with the value 8.\n\nWe were able to succsfully validate and test all the inputs with their given outputs \nas in the json file.\n\n\n'''\n\ndef solve_d0f5fe59(x):\n    row=len(x)\n    col=len(x[0])\n    count=0\n   #Creating a function for Depth first search for finding the islands\n    def dfs(a,row,col,m,n):\n        if a[m][n]==0:\n            return\n        a[m][n]=0\n        \n        if m!=0:\n            dfs(a,row,col,m-1,n)\n    \n        if m!=row-1:\n            dfs(a,row,col,m+1,n)\n    \n        if n!=0:\n            dfs(a,row,col,m,n-1)    \n        if n!=col-1:\n            dfs(a,row,col,m,n+1) \n            #Iterating to count the number of islands   \n    for i in range(row):\n        for j in range(col):\n            if x[i][j]==8:\n                dfs(x,row,col,i,j)\n                count+=1\n     #Creating a zero numpy array with the same dimensions as the number of islands           \n    b=np.zeros((count, count), int)\n    #Filling the diagonal with the value 8\n    np.fill_diagonal(b,8)    \n\n    return b\n\n'''\ndef solve_4093f84a(x)\n\n\nDifficulty Level  according to us : Medium to Difficult\n\nLogic : \n4093f84a.json looked to be simple on the testing interface initially.Logically \nwe needed to find the rectangle with 5's and then determine whether it was a horizontal \none or a vertical one.After that close to the the rectangle  we had to fill the 5 in \nthe respective rows or columns.\n\nWe tried to have a simple approach of finding the bigger island with the rectangle first.\nAfter that we made all the other positions as zero.We noted the positions of the other \nvalues.And then added them to the rectangle in their respective rows and columns.\n\nThe given code use basic python and numpy functions.\nWhile testing this it passed for the test demonstration 1.However there was a \nslight difference in demosntraions 2 and 3 as there were multiple non 5 values in the \nsame row or column.This made it to not completely satisfy the outputs for 2 and 3 and test input grid.\n\nThe idea to solve this would be to get the positions ond the number of such colours \nin a particular row or column.Once we get the number we can add to the same side of \nthe rectangle the cells and this would result in the success of the function\n\n\n'''\n\n\ndef solve_4093f84a(x):\n    x=np.array(x)\n    #Getting positions where the value is non zero\n    mn=np.where(x!=0)\n    #Getting positions where the value is five\n    yz=np.where(x==5)\n    emp_lst=[]\n    #Adding to an empty list the positions of the non 5 and non zero values\n    for i in range(len(mn[0])):\n        if x[mn[0][i]][mn[1][i]]!=5:\n            emp_lst.append([mn[0][i],mn[1][i]])\n    #Making all the non island positions 0 before actioning\n    for m in emp_lst:\n        x[m[0],m[1]]=0\n    #Action to alter the value to 5 for the respective postions near to the island    \n    if np.amin(yz[1])==0:\n        for m in emp_lst:\n            if m[0]<np.amin(yz[0]):\n                x[np.amin(yz[0])-1][m[1]]=5\n            else :\n                x[np.amax(yz[0])+1][m[1]]=5\n    else :\n        for m in emp_lst:\n            if m[1]<np.amin(yz[1]):\n                x[m[0]][np.amin(yz[1])-1]=5\n            else :\n                x[m[0]][np.amax(yz[1])+1]=5\n    return x\n\n\n'''\ndef solve_5ad4f10b(x)\n\nDifficulty Level according to us : Difficult\n\nLogic:\n\nFor solving 5ad4f10b.json we tried to look at various ways for coming up.It seemed \na little difficult.The main challenge was to find the area for the section which was \nto be contracted and then the values updated with the other colour outliers.\n\nFollowing is the approach we followed for this section :\n\n1.Identify the n*n squares(start with 3) in the given array,their coordinates as \nwell and store their values in separate lists.\n2.Get the max and min values of the rows and column numbers for the areas containing squares.\n3.Create a new array with only the rows and columns which  was obtained from Step 2\n4.Clear any other colour values than 0 and the squares and convert it to 0.\n5.Get the other colour value from the original array and create a new array with the specific positions.\n\nWe have used basic numpy and math library to get this output.\n\nThe one limitation to this part of the code is that it is currently useful for \n3*3 squares only(Training Input and output 2 currently. We can use a similar version of \nthe same code by altering the for loops a little to make it working for 4*4 squares as well.\nDue to timing limitations we have not tried it. However we believe the logic would be near \nabout the same and would work for other training and test grids as well with slight modifications.\n'''\n\ndef solve_5ad4f10b(x):\n    a=np.array(x)\n    row,colmn=a.shape[0],a.shape[1]\n    \n     #Code to get the 3*3 squares inside the array\n\n    emp_lst1=[]\n    range_lst1=[]\n    #comp=0\n    for i in range(row):\n        for j in range(colmn):\n            emp_lst=[]\n            range_lst=[]\n            comp=0\n            if i-1>0 and j-1>0 and i+1<row and j+1<colmn:\n                for m in range(i-1,i+2):\n                    for n in range(j-1,j+2):\n                        emp_lst.append(a[m][n])\n                        range_lst.append ((m,n))\n                       \n            if len(emp_lst)>0 and emp_lst[0]!=0:\n                comp=1\n                #print (emp_lst )\n                for mn in emp_lst:\n                    if emp_lst[0]!=mn:\n                        comp+=1 \n            #print(comp)\n            if comp==1 and len(emp_lst)>0:\n                #print(emp_lst)\n                #print(range_lst)\n                emp_lst1.append(emp_lst)\n                range_lst1.append(range_lst)\n                \n    #Getting the minimum and maximum section of the array to be cut            \n    \n    min_row=range_lst1[0][0][0]\n\n    for m in range_lst1:\n        for n in m:\n            if n[0]<min_row:\n                min_row=n[0]\n \n    min_col=range_lst1[0][0][1]\n\n    for m in range_lst1:\n        for n in m:\n            if n[1]<min_col:\n                min_col=n[1]\n    max_row=range_lst1[0][0][0]\n\n    for m in range_lst1:\n        for n in m:\n            if n[0]>max_row:\n                max_row=n[0]\n                \n    max_col=range_lst1[0][0][1]\n\n    for m in range_lst1:\n        for n in m:\n            if n[1]>max_col:\n                max_col=n[1]\n                \n    new_arr=a[min_row:max_row+1,min_col:max_col+1]\n    #Clear the array for any oher number which are outliers\n    new_row,new_col=new_arr.shape[0],new_arr.shape[1]\n    \n    for i in range(new_row):\n        for j in range(new_col):\n            if new_arr[i][j]!=emp_lst1[0][0]:\n                new_arr[i][j]=0\n\n    new_mod_arr=np.zeros((int(math.sqrt(new_row)),int(math.sqrt(new_col))))\n    row_alt,col_alt=new_mod_arr.shape[0],new_mod_arr.shape[1]\n    \n    #Getting the colour value which has to be updated\n    non_zero_val_loc=np.where(a!=0)\n    \n    for m in non_zero_val_loc[0]:\n        for n in non_zero_val_loc[1]:\n            if a[m][n]!=emp_lst1[0][0]:\n                val_to_update=a[m][n]\n    \n    #Updating the new modified array with the intended values\n    for i in range(0,new_row,3):\n        for j in range(0,new_col,3):\n            if new_arr[i][j]!=0:\n                new_i=int(i/3)\n                new_j=int(j/3)\n            #print (new_i,new_j)\n                new_mod_arr[new_i,new_j]=val_to_update\n    return new_mod_arr\n\n''' \n\nA short summary/reflection, commenting on the Python features and libraries you used in the solve * \n\nIn first semester of MSc. while learning and working on assignments we could see maturity \nof available ML packages which can trained on different kind of tasks e.g., NLP task for \nsuggestion mining or regression tasks for prediction of home prices etc. but while working \nwith ARC, we realized that we’re still very far away from building a human like intelligence. \nAll the tasks (.JSON files) when looked in browser, one can identify the patterns in seconds \njust looking at few samples, but it is not easy for ML/programming to generalize this type \nof intelligence. We didn’t find much help on generalised pattern recognition available, \nand ARC is an upcoming new topic in field of AI. We both found it is super interesting \nand addictive i.e., we initially though to just complete 3-4 patterns and submit the assignment \nbut end up coding 8-9 patterns!\n\nWe did not use any ML package or specific libraries but used Numpy and pure python to \ntranslate our understanding of patterns into code. We found that, in future there can \nbe few common functions/libraries be made to recognize the patterns e.g., find specific \nshape objects or enclosed spaces, highlight repetitive patterns, symmetry etc. or correlate \nthe colours in base image to transformed image. These functions in addition to math \nlibraries can be then basis for creating hypothesise in terms of hyper parameters or \nsupport functions. We still have limited understanding of this topic and acknowledge \nthat writing the code to solve all sorts of problems i.e., generalisation is not easy \ntask. \n\n\nCommonalities between the problems :\n\n->Pattern Recognition is very important.\n->Many problems include finding the position of enclosed areas and islands.\n->In many problems we had dimensionality reshaping as well as revaluation of the array.\n->Most of the problems can be solved via if else loops or basic libraray functions.\n  However as mentioned before  there is no one off solution to all problems\n\n\nGithub has been thoroughly used by us for core sharing and working as a team of 2.\nReadme file has been altered as well for reflecting the ARC understanding.\n\nAs mentioned by François Chollet in his paper 'The Measure of Intelligence' the \nsolutions can be generalised only to a limited extent because of some of the limitations \nwhich we could see while solving our given problems.The major limitations were a \ngeneralisation of the problem and limited set of inputs and outputs for training \non the same problem. We could only test what was given to use.We are however aware \nthat there will be many variations in the given formations.\n\nNo doubt there are still many leaps to be taken by Arificial Intelligence!\n\n\n'''\n\n\ndef main():\n    # Find all the functions defined in this file whose names are\n    # like solve_abcd1234(), and run them.\n\n    # regex to match solve_* functions and extract task IDs\n    p = r\"solve_([a-f0-9]{8})\" \n    tasks_solvers = []\n    # globals() gives a dict containing all global names (variables\n    # and functions), as name: value pairs.\n    for name in globals(): \n        m = re.match(p, name)\n        if m:\n            # if the name fits the pattern eg solve_abcd1234\n            ID = m.group(1) # just the task ID\n            solve_fn = globals()[name] # the fn itself\n            tasks_solvers.append((ID, solve_fn))\n\n    for ID, solve_fn in tasks_solvers:\n        # for each task, read the data and call test()\n        directory = os.path.join(\"..\", \"data\", \"training\")\n        json_filename = os.path.join(directory, ID + \".json\")\n        data = read_ARC_JSON(json_filename)\n        test(ID, solve_fn, data)\n    \ndef read_ARC_JSON(filepath):\n    \"\"\"Given a filepath, read in the ARC task data which is in JSON\n    format. Extract the train/test input/output pairs of\n    grids. Convert each grid to np.array and return train_input,\n    train_output, test_input, test_output.\"\"\"\n    \n    # Open the JSON file and load it \n    data = json.load(open(filepath))\n\n    # Extract the train/test input/output grids. Each grid will be a\n    # list of lists of ints. We convert to Numpy.\n    train_input = [np.array(data['train'][i]['input']) for i in range(len(data['train']))]\n    train_output = [np.array(data['train'][i]['output']) for i in range(len(data['train']))]\n    test_input = [np.array(data['test'][i]['input']) for i in range(len(data['test']))]\n    test_output = [np.array(data['test'][i]['output']) for i in range(len(data['test']))]\n\n    return (train_input, train_output, test_input, test_output)\n\n\ndef test(taskID, solve, data):\n    \"\"\"Given a task ID, call the given solve() function on every\n    example in the task data.\"\"\"\n    print(taskID)\n    train_input, train_output, test_input, test_output = data\n    print(\"Training grids\")\n    for x, y in zip(train_input, train_output):\n        yhat = solve(x)\n        show_result(x, y, yhat)\n    print(\"Test grids\")\n    for x, y in zip(test_input, test_output):\n        yhat = solve(x)\n        show_result(x, y, yhat)\n\n        \ndef show_result(x, y, yhat):\n    print(\"Input\")\n    print(x)\n    print(\"Correct output\")\n    print(y)\n    print(\"Our output\")\n    print(yhat)\n    print(\"Correct?\")\n    if y.shape != yhat.shape:\n        print(f\"False. Incorrect shape: {y.shape} v {yhat.shape}\")\n    else:\n        print(np.all(y == yhat))\n\n\nif __name__ == \"__main__\": main()\n\n\n", "meta": {"hexsha": "0b7f5fcd749c08191b46a7f0332b1a7f4e607e21", "size": 27419, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/manual_solve.py", "max_stars_repo_name": "ravi3990/ARC", "max_stars_repo_head_hexsha": "589f21934efda158a093a2a548acdfddf296fe54", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-23T21:16:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-23T21:16:11.000Z", "max_issues_repo_path": "src/manual_solve.py", "max_issues_repo_name": "ravi3990/ARC", "max_issues_repo_head_hexsha": "589f21934efda158a093a2a548acdfddf296fe54", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/manual_solve.py", "max_forks_repo_name": "ravi3990/ARC", "max_forks_repo_head_hexsha": "589f21934efda158a093a2a548acdfddf296fe54", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.9528301887, "max_line_length": 109, "alphanum_fraction": 0.6275575331, "include": true, "reason": "import numpy", "num_tokens": 6629, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.12421301321508335, "lm_q1q2_score": 0.062106506607541676}}
{"text": "# This file is generated automatically through:\n#    d2lbook build lib\n# Don't edit it directly\n\n# Defined in file: ./chapter_preface/index.md\nimport collections\nimport hashlib\nimport math\nimport os\nimport random\nimport re\nimport shutil\nimport sys\nimport tarfile\nimport time\nimport zipfile\nfrom collections import defaultdict\n\nimport pandas as pd\nimport requests\nfrom IPython import display\nfrom matplotlib import pyplot as plt\n\nd2l = sys.modules[__name__]\n\n\n# Defined in file: ./chapter_preface/index.md\nimport numpy as np\nimport tensorflow as tf\n\n\n# Defined in file: ./chapter_preliminaries/calculus.md\ndef use_svg_display():\n    \"\"\"Use the svg format to display a plot in Jupyter.\"\"\"\n    display.set_matplotlib_formats('svg')\n\n\n# Defined in file: ./chapter_preliminaries/calculus.md\ndef set_figsize(figsize=(3.5, 2.5)):\n    \"\"\"Set the figure size for matplotlib.\"\"\"\n    use_svg_display()\n    d2l.plt.rcParams['figure.figsize'] = figsize\n\n\n# Defined in file: ./chapter_preliminaries/calculus.md\ndef set_axes(axes, xlabel, ylabel, xlim, ylim, xscale, yscale, legend):\n    \"\"\"Set the axes for matplotlib.\"\"\"\n    axes.set_xlabel(xlabel)\n    axes.set_ylabel(ylabel)\n    axes.set_xscale(xscale)\n    axes.set_yscale(yscale)\n    axes.set_xlim(xlim)\n    axes.set_ylim(ylim)\n    if legend:\n        axes.legend(legend)\n    axes.grid()\n\n\n# Defined in file: ./chapter_preliminaries/calculus.md\ndef plot(X, Y=None, xlabel=None, ylabel=None, legend=None, xlim=None,\n         ylim=None, xscale='linear', yscale='linear',\n         fmts=('-', 'm--', 'g-.', 'r:'), figsize=(3.5, 2.5), axes=None):\n    \"\"\"Plot data points.\"\"\"\n    if legend is None:\n        legend = []\n\n    set_figsize(figsize)\n    axes = axes if axes else d2l.plt.gca()\n\n    # Return True if `X` (tensor or list) has 1 axis\n    def has_one_axis(X):\n        return (hasattr(X, \"ndim\") and X.ndim == 1 or\n                isinstance(X, list) and not hasattr(X[0], \"__len__\"))\n\n    if has_one_axis(X):\n        X = [X]\n    if Y is None:\n        X, Y = [[]] * len(X), X\n    elif has_one_axis(Y):\n        Y = [Y]\n    if len(X) != len(Y):\n        X = X * len(Y)\n    axes.cla()\n    for x, y, fmt in zip(X, Y, fmts):\n        if len(x):\n            axes.plot(x, y, fmt)\n        else:\n            axes.plot(y, fmt)\n    set_axes(axes, xlabel, ylabel, xlim, ylim, xscale, yscale, legend)\n\n\n# Defined in file: ./chapter_linear-networks/linear-regression.md\nclass Timer:\n    \"\"\"Record multiple running times.\"\"\"\n    def __init__(self):\n        self.times = []\n        self.start()\n\n    def start(self):\n        \"\"\"Start the timer.\"\"\"\n        self.tik = time.time()\n\n    def stop(self):\n        \"\"\"Stop the timer and record the time in a list.\"\"\"\n        self.times.append(time.time() - self.tik)\n        return self.times[-1]\n\n    def avg(self):\n        \"\"\"Return the average time.\"\"\"\n        return sum(self.times) / len(self.times)\n\n    def sum(self):\n        \"\"\"Return the sum of time.\"\"\"\n        return sum(self.times)\n\n    def cumsum(self):\n        \"\"\"Return the accumulated time.\"\"\"\n        return np.array(self.times).cumsum().tolist()\n\n\n# Defined in file: ./chapter_linear-networks/linear-regression-scratch.md\ndef synthetic_data(w, b, num_examples):\n    \"\"\"Generate y = Xw + b + noise.\"\"\"\n    X = d2l.zeros((num_examples, w.shape[0]))\n    X += tf.random.normal(shape=X.shape)\n    y = d2l.matmul(X, tf.reshape(w, (-1, 1))) + b\n    y += tf.random.normal(shape=y.shape, stddev=0.01)\n    y = d2l.reshape(y, (-1, 1))\n    return X, y\n\n\n# Defined in file: ./chapter_linear-networks/linear-regression-scratch.md\ndef linreg(X, w, b):\n    \"\"\"The linear regression model.\"\"\"\n    return d2l.matmul(X, w) + b\n\n\n# Defined in file: ./chapter_linear-networks/linear-regression-scratch.md\ndef squared_loss(y_hat, y):\n    \"\"\"Squared loss.\"\"\"\n    return (y_hat - d2l.reshape(y, y_hat.shape))**2 / 2\n\n\n# Defined in file: ./chapter_linear-networks/linear-regression-scratch.md\ndef sgd(params, grads, lr, batch_size):\n    \"\"\"Minibatch stochastic gradient descent.\"\"\"\n    for param, grad in zip(params, grads):\n        param.assign_sub(lr * grad / batch_size)\n\n\n# Defined in file: ./chapter_linear-networks/linear-regression-concise.md\ndef load_array(data_arrays, batch_size, is_train=True):\n    \"\"\"Construct a TensorFlow data iterator.\"\"\"\n    dataset = tf.data.Dataset.from_tensor_slices(data_arrays)\n    if is_train:\n        dataset = dataset.shuffle(buffer_size=1000)\n    dataset = dataset.batch(batch_size)\n    return dataset\n\n\n# Defined in file: ./chapter_linear-networks/image-classification-dataset.md\ndef get_fashion_mnist_labels(labels):\n    \"\"\"Return text labels for the Fashion-MNIST dataset.\"\"\"\n    text_labels = [\n        't-shirt', 'trouser', 'pullover', 'dress', 'coat', 'sandal', 'shirt',\n        'sneaker', 'bag', 'ankle boot']\n    return [text_labels[int(i)] for i in labels]\n\n\n# Defined in file: ./chapter_linear-networks/image-classification-dataset.md\ndef show_images(imgs, num_rows, num_cols, titles=None, scale=1.5):\n    \"\"\"Plot a list of images.\"\"\"\n    figsize = (num_cols * scale, num_rows * scale)\n    _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)\n    axes = axes.flatten()\n    for i, (ax, img) in enumerate(zip(axes, imgs)):\n        ax.imshow(d2l.numpy(img))\n        ax.axes.get_xaxis().set_visible(False)\n        ax.axes.get_yaxis().set_visible(False)\n        if titles:\n            ax.set_title(titles[i])\n    return axes\n\n\n# Defined in file: ./chapter_linear-networks/image-classification-dataset.md\ndef load_data_fashion_mnist(batch_size, resize=None):\n    \"\"\"Download the Fashion-MNIST dataset and then load it into memory.\"\"\"\n    mnist_train, mnist_test = tf.keras.datasets.fashion_mnist.load_data()\n    # Divide all numbers by 255 so that all pixel values are between\n    # 0 and 1, add a batch dimension at the last. And cast label to int32\n    process = lambda X, y: (tf.expand_dims(X, axis=3) / 255,\n                            tf.cast(y, dtype='int32'))\n    resize_fn = lambda X, y: (tf.image.resize_with_pad(X, resize, resize)\n                              if resize else X, y)\n    return (tf.data.Dataset.from_tensor_slices(\n        process(*mnist_train)).batch(batch_size).shuffle(len(\n            mnist_train[0])).map(resize_fn),\n            tf.data.Dataset.from_tensor_slices(\n                process(*mnist_test)).batch(batch_size).map(resize_fn))\n\n\n# Defined in file: ./chapter_linear-networks/softmax-regression-scratch.md\ndef accuracy(y_hat, y):\n    \"\"\"Compute the number of correct predictions.\"\"\"\n    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:\n        y_hat = d2l.argmax(y_hat, axis=1)\n    cmp = d2l.astype(y_hat, y.dtype) == y\n    return float(d2l.reduce_sum(d2l.astype(cmp, y.dtype)))\n\n\n# Defined in file: ./chapter_linear-networks/softmax-regression-scratch.md\ndef evaluate_accuracy(net, data_iter):\n    \"\"\"Compute the accuracy for a model on a dataset.\"\"\"\n    metric = Accumulator(2)  # No. of correct predictions, no. of predictions\n    for X, y in data_iter:\n        metric.add(accuracy(net(X), y), d2l.size(y))\n    return metric[0] / metric[1]\n\n\n# Defined in file: ./chapter_linear-networks/softmax-regression-scratch.md\nclass Accumulator:\n    \"\"\"For accumulating sums over `n` variables.\"\"\"\n    def __init__(self, n):\n        self.data = [0.0] * n\n\n    def add(self, *args):\n        self.data = [a + float(b) for a, b in zip(self.data, args)]\n\n    def reset(self):\n        self.data = [0.0] * len(self.data)\n\n    def __getitem__(self, idx):\n        return self.data[idx]\n\n\n# Defined in file: ./chapter_linear-networks/softmax-regression-scratch.md\ndef train_epoch_ch3(net, train_iter, loss, updater):\n    \"\"\"The training loop defined in Chapter 3.\"\"\"\n    # Sum of training loss, sum of training accuracy, no. of examples\n    metric = Accumulator(3)\n    for X, y in train_iter:\n        # Compute gradients and update parameters\n        with tf.GradientTape() as tape:\n            y_hat = net(X)\n            # Keras implementations for loss takes (labels, predictions)\n            # instead of (predictions, labels) that users might implement\n            # in this book, e.g. `cross_entropy` that we implemented above\n            if isinstance(loss, tf.keras.losses.Loss):\n                l = loss(y, y_hat)\n            else:\n                l = loss(y_hat, y)\n        if isinstance(updater, tf.keras.optimizers.Optimizer):\n            params = net.trainable_variables\n            grads = tape.gradient(l, params)\n            updater.apply_gradients(zip(grads, params))\n        else:\n            updater(X.shape[0], tape.gradient(l, updater.params))\n        # Keras loss by default returns the average loss in a batch\n        l_sum = l * float(tf.size(y)) if isinstance(\n            loss, tf.keras.losses.Loss) else tf.reduce_sum(l)\n        metric.add(l_sum, accuracy(y_hat, y), tf.size(y))\n    # Return training loss and training accuracy\n    return metric[0] / metric[2], metric[1] / metric[2]\n\n\n# Defined in file: ./chapter_linear-networks/softmax-regression-scratch.md\nclass Animator:\n    \"\"\"For plotting data in animation.\"\"\"\n    def __init__(self, xlabel=None, ylabel=None, legend=None, xlim=None,\n                 ylim=None, xscale='linear', yscale='linear',\n                 fmts=('-', 'm--', 'g-.', 'r:'), nrows=1, ncols=1,\n                 figsize=(3.5, 2.5)):\n        # Incrementally plot multiple lines\n        if legend is None:\n            legend = []\n        d2l.use_svg_display()\n        self.fig, self.axes = d2l.plt.subplots(nrows, ncols, figsize=figsize)\n        if nrows * ncols == 1:\n            self.axes = [self.axes,]\n        # Use a lambda function to capture arguments\n        self.config_axes = lambda: d2l.set_axes(self.axes[\n            0], xlabel, ylabel, xlim, ylim, xscale, yscale, legend)\n        self.X, self.Y, self.fmts = None, None, fmts\n\n    def add(self, x, y):\n        # Add multiple data points into the figure\n        if not hasattr(y, \"__len__\"):\n            y = [y]\n        n = len(y)\n        if not hasattr(x, \"__len__\"):\n            x = [x] * n\n        if not self.X:\n            self.X = [[] for _ in range(n)]\n        if not self.Y:\n            self.Y = [[] for _ in range(n)]\n        for i, (a, b) in enumerate(zip(x, y)):\n            if a is not None and b is not None:\n                self.X[i].append(a)\n                self.Y[i].append(b)\n        self.axes[0].cla()\n        for x, y, fmt in zip(self.X, self.Y, self.fmts):\n            self.axes[0].plot(x, y, fmt)\n        self.config_axes()\n        display.display(self.fig)\n        display.clear_output(wait=True)\n\n\n# Defined in file: ./chapter_linear-networks/softmax-regression-scratch.md\ndef train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):\n    \"\"\"Train a model (defined in Chapter 3).\"\"\"\n    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],\n                        legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)\n        test_acc = evaluate_accuracy(net, test_iter)\n        animator.add(epoch + 1, train_metrics + (test_acc,))\n    train_loss, train_acc = train_metrics\n    assert train_loss < 0.5, train_loss\n    assert train_acc <= 1 and train_acc > 0.7, train_acc\n    assert test_acc <= 1 and test_acc > 0.7, test_acc\n\n\n# Defined in file: ./chapter_linear-networks/softmax-regression-scratch.md\nclass Updater():\n    \"\"\"For updating parameters using minibatch stochastic gradient descent.\"\"\"\n    def __init__(self, params, lr):\n        self.params = params\n        self.lr = lr\n\n    def __call__(self, batch_size, grads):\n        d2l.sgd(self.params, grads, self.lr, batch_size)\n\n\n# Defined in file: ./chapter_linear-networks/softmax-regression-scratch.md\ndef predict_ch3(net, test_iter, n=6):\n    \"\"\"Predict labels (defined in Chapter 3).\"\"\"\n    for X, y in test_iter:\n        break\n    trues = d2l.get_fashion_mnist_labels(y)\n    preds = d2l.get_fashion_mnist_labels(d2l.argmax(net(X), axis=1))\n    titles = [true + '\\n' + pred for true, pred in zip(trues, preds)]\n    d2l.show_images(d2l.reshape(X[0:n], (n, 28, 28)), 1, n,\n                    titles=titles[0:n])\n\n\n# Defined in file: ./chapter_multilayer-perceptrons/underfit-overfit.md\ndef evaluate_loss(net, data_iter, loss):\n    \"\"\"Evaluate the loss of a model on the given dataset.\"\"\"\n    metric = d2l.Accumulator(2)  # Sum of losses, no. of examples\n    for X, y in data_iter:\n        l = loss(net(X), y)\n        metric.add(d2l.reduce_sum(l), d2l.size(l))\n    return metric[0] / metric[1]\n\n\n# Defined in file: ./chapter_multilayer-perceptrons/kaggle-house-price.md\nDATA_HUB = dict()\nDATA_URL = 'http://d2l-data.s3-accelerate.amazonaws.com/'\n\n\n# Defined in file: ./chapter_multilayer-perceptrons/kaggle-house-price.md\ndef download(name, cache_dir=os.path.join('..', 'data')):\n    \"\"\"Download a file inserted into DATA_HUB, return the local filename.\"\"\"\n    assert name in DATA_HUB, f\"{name} does not exist in {DATA_HUB}.\"\n    url, sha1_hash = DATA_HUB[name]\n    os.makedirs(cache_dir, exist_ok=True)\n    fname = os.path.join(cache_dir, url.split('/')[-1])\n    if os.path.exists(fname):\n        sha1 = hashlib.sha1()\n        with open(fname, 'rb') as f:\n            while True:\n                data = f.read(1048576)\n                if not data:\n                    break\n                sha1.update(data)\n        if sha1.hexdigest() == sha1_hash:\n            return fname  # Hit cache\n    print(f'Downloading {fname} from {url}...')\n    r = requests.get(url, stream=True, verify=True)\n    with open(fname, 'wb') as f:\n        f.write(r.content)\n    return fname\n\n\n# Defined in file: ./chapter_multilayer-perceptrons/kaggle-house-price.md\ndef download_extract(name, folder=None):\n    \"\"\"Download and extract a zip/tar file.\"\"\"\n    fname = download(name)\n    base_dir = os.path.dirname(fname)\n    data_dir, ext = os.path.splitext(fname)\n    if ext == '.zip':\n        fp = zipfile.ZipFile(fname, 'r')\n    elif ext in ('.tar', '.gz'):\n        fp = tarfile.open(fname, 'r')\n    else:\n        assert False, 'Only zip/tar files can be extracted.'\n    fp.extractall(base_dir)\n    return os.path.join(base_dir, folder) if folder else data_dir\n\n\ndef download_all():\n    \"\"\"Download all files in the DATA_HUB.\"\"\"\n    for name in DATA_HUB:\n        download(name)\n\n\n# Defined in file: ./chapter_multilayer-perceptrons/kaggle-house-price.md\nDATA_HUB['kaggle_house_train'] = (DATA_URL + 'kaggle_house_pred_train.csv',\n                                  '585e9cc93e70b39160e7921475f9bcd7d31219ce')\n\nDATA_HUB['kaggle_house_test'] = (DATA_URL + 'kaggle_house_pred_test.csv',\n                                 'fa19780a7b011d9b009e8bff8e99922a8ee2eb90')\n\n\n# Defined in file: ./chapter_deep-learning-computation/use-gpu.md\ndef try_gpu(i=0):\n    \"\"\"Return gpu(i) if exists, otherwise return cpu().\"\"\"\n    if len(tf.config.experimental.list_physical_devices('GPU')) >= i + 1:\n        return tf.device(f'/GPU:{i}')\n    return tf.device('/CPU:0')\n\n\ndef try_all_gpus():\n    \"\"\"Return all available GPUs, or [cpu(),] if no GPU exists.\"\"\"\n    num_gpus = len(tf.config.experimental.list_physical_devices('GPU'))\n    devices = [tf.device(f'/GPU:{i}') for i in range(num_gpus)]\n    return devices if devices else [tf.device('/CPU:0')]\n\n\n# Defined in file: ./chapter_convolutional-neural-networks/conv-layer.md\ndef corr2d(X, K):\n    \"\"\"Compute 2D cross-correlation.\"\"\"\n    h, w = K.shape\n    Y = tf.Variable(tf.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1)))\n    for i in range(Y.shape[0]):\n        for j in range(Y.shape[1]):\n            Y[i, j].assign(tf.reduce_sum(X[i:i + h, j:j + w] * K))\n    return Y\n\n\n# Defined in file: ./chapter_convolutional-neural-networks/lenet.md\nclass TrainCallback(tf.keras.callbacks.Callback):\n    \"\"\"A callback to visiualize the training progress.\"\"\"\n    def __init__(self, net, train_iter, test_iter, num_epochs, device_name):\n        self.timer = d2l.Timer()\n        self.animator = d2l.Animator(\n            xlabel='epoch', xlim=[1, num_epochs],\n            legend=['train loss', 'train acc', 'test acc'])\n        self.net = net\n        self.train_iter = train_iter\n        self.test_iter = test_iter\n        self.num_epochs = num_epochs\n        self.device_name = device_name\n\n    def on_epoch_begin(self, epoch, logs=None):\n        self.timer.start()\n\n    def on_epoch_end(self, epoch, logs):\n        self.timer.stop()\n        test_acc = self.net.evaluate(self.test_iter, verbose=0,\n                                     return_dict=True)['accuracy']\n        metrics = (logs['loss'], logs['accuracy'], test_acc)\n        self.animator.add(epoch + 1, metrics)\n        if epoch == self.num_epochs - 1:\n            batch_size = next(iter(self.train_iter))[0].shape[0]\n            num_examples = batch_size * tf.data.experimental.cardinality(\n                self.train_iter).numpy()\n            print(f'loss {metrics[0]:.3f}, train acc {metrics[1]:.3f}, '\n                  f'test acc {metrics[2]:.3f}')\n            print(f'{num_examples / self.timer.avg():.1f} examples/sec on '\n                  f'{str(self.device_name)}')\n\n\ndef train_ch6(net_fn, train_iter, test_iter, num_epochs, lr, device):\n    \"\"\"Train a model with a GPU (defined in Chapter 6).\"\"\"\n    device_name = device._device_name\n    strategy = tf.distribute.OneDeviceStrategy(device_name)\n    with strategy.scope():\n        optimizer = tf.keras.optimizers.SGD(learning_rate=lr)\n        loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n        net = net_fn()\n        net.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])\n    callback = TrainCallback(net, train_iter, test_iter, num_epochs,\n                             device_name)\n    net.fit(train_iter, epochs=num_epochs, verbose=0, callbacks=[callback])\n    return net\n\n\n# Defined in file: ./chapter_convolutional-modern/resnet.md\nclass Residual(tf.keras.Model):\n    \"\"\"The Residual block of ResNet.\"\"\"\n    def __init__(self, num_channels, use_1x1conv=False, strides=1):\n        super().__init__()\n        self.conv1 = tf.keras.layers.Conv2D(num_channels, padding='same',\n                                            kernel_size=3, strides=strides)\n        self.conv2 = tf.keras.layers.Conv2D(num_channels, kernel_size=3,\n                                            padding='same')\n        self.conv3 = None\n        if use_1x1conv:\n            self.conv3 = tf.keras.layers.Conv2D(num_channels, kernel_size=1,\n                                                strides=strides)\n        self.bn1 = tf.keras.layers.BatchNormalization()\n        self.bn2 = tf.keras.layers.BatchNormalization()\n\n    def call(self, X):\n        Y = tf.keras.activations.relu(self.bn1(self.conv1(X)))\n        Y = self.bn2(self.conv2(Y))\n        if self.conv3 is not None:\n            X = self.conv3(X)\n        Y += X\n        return tf.keras.activations.relu(Y)\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/text-preprocessing.md\nd2l.DATA_HUB['time_machine'] = (d2l.DATA_URL + 'timemachine.txt',\n                                '090b5e7e70c295757f55df93cb0a180b9691891a')\n\n\ndef read_time_machine():\n    \"\"\"Load the time machine dataset into a list of text lines.\"\"\"\n    with open(d2l.download('time_machine'), 'r') as f:\n        lines = f.readlines()\n    return [re.sub('[^A-Za-z]+', ' ', line).strip().lower() for line in lines]\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/text-preprocessing.md\ndef tokenize(lines, token='word'):\n    \"\"\"Split text lines into word or character tokens.\"\"\"\n    if token == 'word':\n        return [line.split() for line in lines]\n    elif token == 'char':\n        return [list(line) for line in lines]\n    else:\n        print('ERROR: unknown token type: ' + token)\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/text-preprocessing.md\nclass Vocab:\n    \"\"\"Vocabulary for text.\"\"\"\n    def __init__(self, tokens=None, min_freq=0, reserved_tokens=None):\n        if tokens is None:\n            tokens = []\n        if reserved_tokens is None:\n            reserved_tokens = []\n        # Sort according to frequencies\n        counter = count_corpus(tokens)\n        self.token_freqs = sorted(counter.items(), key=lambda x: x[1],\n                                  reverse=True)\n        # The index for the unknown token is 0\n        self.unk, uniq_tokens = 0, ['<unk>'] + reserved_tokens\n        uniq_tokens += [\n            token for token, freq in self.token_freqs\n            if freq >= min_freq and token not in uniq_tokens]\n        self.idx_to_token, self.token_to_idx = [], dict()\n        for token in uniq_tokens:\n            self.idx_to_token.append(token)\n            self.token_to_idx[token] = len(self.idx_to_token) - 1\n\n    def __len__(self):\n        return len(self.idx_to_token)\n\n    def __getitem__(self, tokens):\n        if not isinstance(tokens, (list, tuple)):\n            return self.token_to_idx.get(tokens, self.unk)\n        return [self.__getitem__(token) for token in tokens]\n\n    def to_tokens(self, indices):\n        if not isinstance(indices, (list, tuple)):\n            return self.idx_to_token[indices]\n        return [self.idx_to_token[index] for index in indices]\n\n\ndef count_corpus(tokens):\n    \"\"\"Count token frequencies.\"\"\"\n    # Here `tokens` is a 1D list or 2D list\n    if len(tokens) == 0 or isinstance(tokens[0], list):\n        # Flatten a list of token lists into a list of tokens\n        tokens = [token for line in tokens for token in line]\n    return collections.Counter(tokens)\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/text-preprocessing.md\ndef load_corpus_time_machine(max_tokens=-1):\n    \"\"\"Return token indices and the vocabulary of the time machine dataset.\"\"\"\n    lines = read_time_machine()\n    tokens = tokenize(lines, 'char')\n    vocab = Vocab(tokens)\n    # Since each text line in the time machine dataset is not necessarily a\n    # sentence or a paragraph, flatten all the text lines into a single list\n    corpus = [vocab[token] for line in tokens for token in line]\n    if max_tokens > 0:\n        corpus = corpus[:max_tokens]\n    return corpus, vocab\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/language-models-and-dataset.md\ndef seq_data_iter_random(corpus, batch_size, num_steps):\n    \"\"\"Generate a minibatch of subsequences using random sampling.\"\"\"\n    # Start with a random offset (inclusive of `num_steps - 1`) to partition a\n    # sequence\n    corpus = corpus[random.randint(0, num_steps - 1):]\n    # Subtract 1 since we need to account for labels\n    num_subseqs = (len(corpus) - 1) // num_steps\n    # The starting indices for subsequences of length `num_steps`\n    initial_indices = list(range(0, num_subseqs * num_steps, num_steps))\n    # In random sampling, the subsequences from two adjacent random\n    # minibatches during iteration are not necessarily adjacent on the\n    # original sequence\n    random.shuffle(initial_indices)\n\n    def data(pos):\n        # Return a sequence of length `num_steps` starting from `pos`\n        return corpus[pos:pos + num_steps]\n\n    num_batches = num_subseqs // batch_size\n    for i in range(0, batch_size * num_batches, batch_size):\n        # Here, `initial_indices` contains randomized starting indices for\n        # subsequences\n        initial_indices_per_batch = initial_indices[i:i + batch_size]\n        X = [data(j) for j in initial_indices_per_batch]\n        Y = [data(j + 1) for j in initial_indices_per_batch]\n        yield d2l.tensor(X), d2l.tensor(Y)\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/language-models-and-dataset.md\ndef seq_data_iter_sequential(corpus, batch_size, num_steps):\n    \"\"\"Generate a minibatch of subsequences using sequential partitioning.\"\"\"\n    # Start with a random offset to partition a sequence\n    offset = random.randint(0, num_steps)\n    num_tokens = ((len(corpus) - offset - 1) // batch_size) * batch_size\n    Xs = d2l.tensor(corpus[offset:offset + num_tokens])\n    Ys = d2l.tensor(corpus[offset + 1:offset + 1 + num_tokens])\n    Xs = d2l.reshape(Xs, (batch_size, -1))\n    Ys = d2l.reshape(Ys, (batch_size, -1))\n    num_batches = Xs.shape[1] // num_steps\n    for i in range(0, num_batches * num_steps, num_steps):\n        X = Xs[:, i:i + num_steps]\n        Y = Ys[:, i:i + num_steps]\n        yield X, Y\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/language-models-and-dataset.md\nclass SeqDataLoader:\n    \"\"\"An iterator to load sequence data.\"\"\"\n    def __init__(self, batch_size, num_steps, use_random_iter, max_tokens):\n        if use_random_iter:\n            self.data_iter_fn = d2l.seq_data_iter_random\n        else:\n            self.data_iter_fn = d2l.seq_data_iter_sequential\n        self.corpus, self.vocab = d2l.load_corpus_time_machine(max_tokens)\n        self.batch_size, self.num_steps = batch_size, num_steps\n\n    def __iter__(self):\n        return self.data_iter_fn(self.corpus, self.batch_size, self.num_steps)\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/language-models-and-dataset.md\ndef load_data_time_machine(batch_size, num_steps, use_random_iter=False,\n                           max_tokens=10000):\n    \"\"\"Return the iterator and the vocabulary of the time machine dataset.\"\"\"\n    data_iter = SeqDataLoader(batch_size, num_steps, use_random_iter,\n                              max_tokens)\n    return data_iter, data_iter.vocab\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/rnn-scratch.md\nclass RNNModelScratch:\n    \"\"\"A RNN Model implemented from scratch.\"\"\"\n    def __init__(self, vocab_size, num_hiddens, init_state, forward_fn,\n                 get_params):\n        self.vocab_size, self.num_hiddens = vocab_size, num_hiddens\n        self.init_state, self.forward_fn = init_state, forward_fn\n        self.trainable_variables = get_params(vocab_size, num_hiddens)\n\n    def __call__(self, X, state):\n        X = tf.one_hot(tf.transpose(X), self.vocab_size)\n        X = tf.cast(X, tf.float32)\n        return self.forward_fn(X, state, self.trainable_variables)\n\n    def begin_state(self, batch_size, *args, **kwargs):\n        return self.init_state(batch_size, self.num_hiddens)\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/rnn-scratch.md\ndef predict_ch8(prefix, num_preds, net, vocab):\n    \"\"\"Generate new characters following the `prefix`.\"\"\"\n    state = net.begin_state(batch_size=1, dtype=tf.float32)\n    outputs = [vocab[prefix[0]]]\n    get_input = lambda: d2l.reshape(d2l.tensor([outputs[-1]]), (1, 1)).numpy()\n    for y in prefix[1:]:  # Warm-up period\n        _, state = net(get_input(), state)\n        outputs.append(vocab[y])\n    for _ in range(num_preds):  # Predict `num_preds` steps\n        y, state = net(get_input(), state)\n        outputs.append(int(y.numpy().argmax(axis=1).reshape(1)))\n    return ''.join([vocab.idx_to_token[i] for i in outputs])\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/rnn-scratch.md\ndef grad_clipping(grads, theta):\n    \"\"\"Clip the gradient.\"\"\"\n    theta = tf.constant(theta, dtype=tf.float32)\n    norm = tf.math.sqrt(\n        sum((tf.reduce_sum(grad**2)).numpy() for grad in grads))\n    norm = tf.cast(norm, tf.float32)\n    new_grad = []\n    if tf.greater(norm, theta):\n        for grad in grads:\n            new_grad.append(grad * theta / norm)\n    else:\n        for grad in grads:\n            new_grad.append(grad)\n    return new_grad\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/rnn-scratch.md\ndef train_epoch_ch8(net, train_iter, loss, updater, use_random_iter):\n    \"\"\"Train a model within one epoch (defined in Chapter 8).\"\"\"\n    state, timer = None, d2l.Timer()\n    metric = d2l.Accumulator(2)  # Sum of training loss, no. of tokens\n    for X, Y in train_iter:\n        if state is None or use_random_iter:\n            # Initialize `state` when either it is the first iteration or\n            # using random sampling\n            state = net.begin_state(batch_size=X.shape[0], dtype=tf.float32)\n        with tf.GradientTape(persistent=True) as g:\n            y_hat, state = net(X, state)\n            y = d2l.reshape(tf.transpose(Y), (-1))\n            l = loss(y, y_hat)\n        params = net.trainable_variables\n        grads = g.gradient(l, params)\n        grads = grad_clipping(grads, 1)\n        updater.apply_gradients(zip(grads, params))\n\n        # Keras loss by default returns the average loss in a batch\n        # l_sum = l * float(d2l.size(y)) if isinstance(\n        #     loss, tf.keras.losses.Loss) else tf.reduce_sum(l)\n        metric.add(l * d2l.size(y), d2l.size(y))\n    return math.exp(metric[0] / metric[1]), metric[1] / timer.stop()\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/rnn-scratch.md\ndef train_ch8(net, train_iter, vocab, lr, num_epochs, strategy,\n              use_random_iter=False):\n    \"\"\"Train a model (defined in Chapter 8).\"\"\"\n    with strategy.scope():\n        loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n        updater = tf.keras.optimizers.SGD(lr)\n    animator = d2l.Animator(xlabel='epoch', ylabel='perplexity',\n                            legend=['train'], xlim=[10, num_epochs])\n    predict = lambda prefix: predict_ch8(prefix, 50, net, vocab)\n    # Train and predict\n    for epoch in range(num_epochs):\n        ppl, speed = train_epoch_ch8(net, train_iter, loss, updater,\n                                     use_random_iter)\n        if (epoch + 1) % 10 == 0:\n            print(predict('time traveller'))\n            animator.add(epoch + 1, [ppl])\n    device = d2l.try_gpu()._device_name\n    print(f'perplexity {ppl:.1f}, {speed:.1f} tokens/sec on {str(device)}')\n    print(predict('time traveller'))\n    print(predict('traveller'))\n\n\n# Defined in file: ./chapter_recurrent-neural-networks/rnn-concise.md\nclass RNNModel(tf.keras.layers.Layer):\n    def __init__(self, rnn_layer, vocab_size, **kwargs):\n        super(RNNModel, self).__init__(**kwargs)\n        self.rnn = rnn_layer\n        self.vocab_size = vocab_size\n        self.dense = tf.keras.layers.Dense(vocab_size)\n\n    def call(self, inputs, state):\n        X = tf.one_hot(tf.transpose(inputs), self.vocab_size)\n        # Later RNN like `tf.keras.layers.LSTMCell` return more than two values\n        Y, *state = self.rnn(X, state)\n        output = self.dense(tf.reshape(Y, (-1, Y.shape[-1])))\n        return output, state\n\n    def begin_state(self, *args, **kwargs):\n        return self.rnn.cell.get_initial_state(*args, **kwargs)\n\n\n# Defined in file: ./chapter_recurrent-modern/machine-translation-and-dataset.md\nd2l.DATA_HUB['fra-eng'] = (d2l.DATA_URL + 'fra-eng.zip',\n                           '94646ad1522d915e7b0f9296181140edcf86a4f5')\n\n\ndef read_data_nmt():\n    \"\"\"Load the English-French dataset.\"\"\"\n    data_dir = d2l.download_extract('fra-eng')\n    with open(os.path.join(data_dir, 'fra.txt'), 'r') as f:\n        return f.read()\n\n\n# Defined in file: ./chapter_recurrent-modern/machine-translation-and-dataset.md\ndef preprocess_nmt(text):\n    \"\"\"Preprocess the English-French dataset.\"\"\"\n    def no_space(char, prev_char):\n        return char in set(',.!?') and prev_char != ' '\n\n    # Replace non-breaking space with space, and convert uppercase letters to\n    # lowercase ones\n    text = text.replace('\\u202f', ' ').replace('\\xa0', ' ').lower()\n    # Insert space between words and punctuation marks\n    out = [\n        ' ' + char if i > 0 and no_space(char, text[i - 1]) else char\n        for i, char in enumerate(text)]\n    return ''.join(out)\n\n\n# Defined in file: ./chapter_recurrent-modern/machine-translation-and-dataset.md\ndef tokenize_nmt(text, num_examples=None):\n    \"\"\"Tokenize the English-French dataset.\"\"\"\n    source, target = [], []\n    for i, line in enumerate(text.split('\\n')):\n        if num_examples and i > num_examples:\n            break\n        parts = line.split('\\t')\n        if len(parts) == 2:\n            source.append(parts[0].split(' '))\n            target.append(parts[1].split(' '))\n    return source, target\n\n\n# Defined in file: ./chapter_recurrent-modern/machine-translation-and-dataset.md\ndef truncate_pad(line, num_steps, padding_token):\n    \"\"\"Truncate or pad sequences.\"\"\"\n    if len(line) > num_steps:\n        return line[:num_steps]  # Truncate\n    return line + [padding_token] * (num_steps - len(line))  # Pad\n\n\n# Defined in file: ./chapter_recurrent-modern/machine-translation-and-dataset.md\ndef build_array_nmt(lines, vocab, num_steps):\n    \"\"\"Transform text sequences of machine translation into minibatches.\"\"\"\n    lines = [vocab[l] for l in lines]\n    lines = [l + [vocab['<eos>']] for l in lines]\n    array = d2l.tensor([\n        truncate_pad(l, num_steps, vocab['<pad>']) for l in lines])\n    valid_len = d2l.reduce_sum(d2l.astype(array != vocab['<pad>'], d2l.int32),\n                               1)\n    return array, valid_len\n\n\n# Defined in file: ./chapter_recurrent-modern/machine-translation-and-dataset.md\ndef load_data_nmt(batch_size, num_steps, num_examples=600):\n    \"\"\"Return the iterator and the vocabularies of the translation dataset.\"\"\"\n    text = preprocess_nmt(read_data_nmt())\n    source, target = tokenize_nmt(text, num_examples)\n    src_vocab = d2l.Vocab(source, min_freq=2,\n                          reserved_tokens=['<pad>', '<bos>', '<eos>'])\n    tgt_vocab = d2l.Vocab(target, min_freq=2,\n                          reserved_tokens=['<pad>', '<bos>', '<eos>'])\n    src_array, src_valid_len = build_array_nmt(source, src_vocab, num_steps)\n    tgt_array, tgt_valid_len = build_array_nmt(target, tgt_vocab, num_steps)\n    data_arrays = (src_array, src_valid_len, tgt_array, tgt_valid_len)\n    data_iter = d2l.load_array(data_arrays, batch_size)\n    return data_iter, src_vocab, tgt_vocab\n\n\n# Defined in file: ./chapter_attention-mechanisms/attention-cues.md\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5),\n                  cmap='Reds'):\n    d2l.use_svg_display()\n    num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n    fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize,\n                                 sharex=True, sharey=True, squeeze=False)\n    for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n        for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n            pcm = ax.imshow(d2l.numpy(matrix), cmap=cmap)\n            if i == num_rows - 1:\n                ax.set_xlabel(xlabel)\n            if j == 0:\n                ax.set_ylabel(ylabel)\n            if titles:\n                ax.set_title(titles[j])\n    fig.colorbar(pcm, ax=axes, shrink=0.6)\n\n\n# Defined in file: ./chapter_optimization/optimization-intro.md\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext,\n                           arrowprops=dict(arrowstyle='->'))\n\n\n# Defined in file: ./chapter_optimization/gd.md\ndef train_2d(trainer, steps=20, f_grad=None):\n    \"\"\"Optimize a 2D objective function with a customized trainer.\"\"\"\n    # `s1` and `s2` are internal state variables that will be used later\n    x1, x2, s1, s2 = -5, -2, 0, 0\n    results = [(x1, x2)]\n    for i in range(steps):\n        if f_grad:\n            x1, x2, s1, s2 = trainer(x1, x2, s1, s2, f_grad)\n        else:\n            x1, x2, s1, s2 = trainer(x1, x2, s1, s2)\n        results.append((x1, x2))\n    print(f'epoch {i + 1}, x1: {float(x1):f}, x2: {float(x2):f}')\n    return results\n\n\ndef show_trace_2d(f, results):\n    \"\"\"Show the trace of 2D variables during optimization.\"\"\"\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='#ff7f0e')\n    x1, x2 = d2l.meshgrid(d2l.arange(-5.5, 1.0, 0.1),\n                          d2l.arange(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='#1f77b4')\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\n\n\n# Defined in file: ./chapter_optimization/minibatch-sgd.md\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat',\n                           '76e5be1548fd8222e5074cf0faae75edff8cf93f')\n\n\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32,\n                         delimiter='\\t')\n    data = (data - data.mean(axis=0)) / data.std(axis=0)\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size,\n                               is_train=True)\n    return data_iter, data.shape[1] - 1\n\n\n# Defined in file: ./chapter_optimization/minibatch-sgd.md\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim,\n               num_epochs=2):\n    # Initialization\n    w = tf.Variable(\n        tf.random.normal(shape=(feature_dim, 1), mean=0, stddev=0.01),\n        trainable=True)\n    b = tf.Variable(tf.zeros(1), trainable=True)\n\n    # Train\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss',\n                            xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n                l = tf.math.reduce_mean(loss(net(X), y))\n\n            dw, db = g.gradient(l, [w, b])\n            trainer_fn([w, b], [dw, db], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n / X.shape[0]\n                q = p / tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss),)\n                animator.add(q, r)\n                timer.start()\n    print(f'loss: {animator.Y[0][-1]:.3f}, {timer.avg():.3f} sec/epoch')\n    return timer.cumsum(), animator.Y[0]\n\n\n# Defined in file: ./chapter_optimization/minibatch-sgd.md\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=2):\n    # Initialization\n    net = tf.keras.Sequential()\n    net.add(\n        tf.keras.layers.Dense(\n            1, kernel_initializer=tf.random_normal_initializer(stddev=0.01)))\n    optimizer = trainer_fn(**hyperparams)\n    loss = tf.keras.losses.MeanSquaredError()\n    # Note: L2 Loss = 1/2 * MSE Loss. TensorFlow has MSE Loss which is\n    # slightly different from MXNet's L2Loss by a factor of 2. Hence we halve\n    # the loss value to get L2Loss in TensorFlow\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss',\n                            xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n                out = net(X)\n                l = loss(y, out) / 2\n                params = net.trainable_variables\n                grads = g.gradient(l, params)\n            optimizer.apply_gradients(zip(grads, params))\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n / X.shape[0]\n                q = p / tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss) / 2,)\n                animator.add(q, r)\n                timer.start()\n    print(f'loss: {animator.Y[0][-1]:.3f}, {timer.avg():.3f} sec/epoch')\n\n\n# Defined in file: ./chapter_computational-performance/hybridize.md\nclass Benchmark:\n    def __init__(self, description='Done'):\n        self.description = description\n\n    def __enter__(self):\n        self.timer = d2l.Timer()\n        return self\n\n    def __exit__(self, *args):\n        print(f'{self.description}: {self.timer.stop():.4f} sec')\n\n\n# Defined in file: ./chapter_computer-vision/bounding-box.md\ndef box_corner_to_center(boxes):\n    \"\"\"Convert from (upper_left, bottom_right) to (center, width, height)\"\"\"\n    x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]\n    cx = (x1 + x2) / 2\n    cy = (y1 + y2) / 2\n    w = x2 - x1\n    h = y2 - y1\n    boxes = d2l.stack((cx, cy, w, h), axis=-1)\n    return boxes\n\n\ndef box_center_to_corner(boxes):\n    \"\"\"Convert from (center, width, height) to (upper_left, bottom_right)\"\"\"\n    cx, cy, w, h = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]\n    x1 = cx - 0.5 * w\n    y1 = cy - 0.5 * h\n    x2 = cx + 0.5 * w\n    y2 = cy + 0.5 * h\n    boxes = d2l.stack((x1, y1, x2, y2), axis=-1)\n    return boxes\n\n\n# Defined in file: ./chapter_computer-vision/bounding-box.md\ndef bbox_to_rect(bbox, color):\n    \"\"\"Convert bounding box to matplotlib format.\"\"\"\n    # Convert the bounding box (top-left x, top-left y, bottom-right x,\n    # bottom-right y) format to matplotlib format: ((upper-left x,\n    # upper-left y), width, height)\n    return d2l.plt.Rectangle(xy=(bbox[0], bbox[1]), width=bbox[2] - bbox[0],\n                             height=bbox[3] - bbox[1], fill=False,\n                             edgecolor=color, linewidth=2)\n\n\n# Alias defined in config.ini\nsize = lambda a: tf.size(a).numpy()\n\nreshape = tf.reshape\nones = tf.ones\nzeros = tf.zeros\nmeshgrid = tf.meshgrid\nsin = tf.sin\nsinh = tf.sinh\ncos = tf.cos\ncosh = tf.cosh\ntanh = tf.tanh\nlinspace = tf.linspace\nexp = tf.exp\nnormal = tf.random.normal\nrand = tf.random.uniform\nmatmul = tf.matmul\nreduce_sum = tf.reduce_sum\nargmax = tf.argmax\ntensor = tf.constant\narange = tf.range\nastype = tf.cast\nint32 = tf.int32\nfloat32 = tf.float32\ntranspose = tf.transpose\nconcat = tf.concat\nstack = tf.stack\nabs = tf.abs\neye = tf.eye\nnumpy = lambda x, *args, **kwargs: x.numpy(*args, **kwargs)\n\n", "meta": {"hexsha": "7c4af4155fb31aa9529ac632060bd0e2b6ad875a", "size": 41108, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/d21-en/tensorflow/d2l/tensorflow.py", "max_stars_repo_name": "lucmertins/CapDeepLearningBook", "max_stars_repo_head_hexsha": "e5959b552c8716e7fc65a21ae9c13c58509544c1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "scripts/d21-en/tensorflow/d2l/tensorflow.py", "max_issues_repo_name": "lucmertins/CapDeepLearningBook", "max_issues_repo_head_hexsha": "e5959b552c8716e7fc65a21ae9c13c58509544c1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scripts/d21-en/tensorflow/d2l/tensorflow.py", "max_forks_repo_name": "lucmertins/CapDeepLearningBook", "max_forks_repo_head_hexsha": "e5959b552c8716e7fc65a21ae9c13c58509544c1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.2756052142, "max_line_length": 85, "alphanum_fraction": 0.6318234893, "include": true, "reason": "import numpy", "num_tokens": 10767, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44167300566462553, "lm_q2_score": 0.1403362530854946, "lm_q1q2_score": 0.06198273470398198}}
{"text": "# To add a new cell, type '# %%'\n# To add a new markdown cell, type '# %% [markdown]'\n# %%\nfrom IPython import get_ipython\n\n# %%\nfrom IPython import get_ipython\n\n# %% [markdown]\n#  # COVID-19 Epidemiology Models\n# %% [markdown]\n#  First, some preliminary imports. You may need to pip install `holoviews` and `GitPython`. For `holoviews`, some extras might be needed (see https://holoviews.org/install.html).\n\n# %%\nimport pandas as pd\nimport numpy as np\nimport scipy.integrate\nimport matplotlib.pyplot as plt\n\nimport bokeh.io\nimport bokeh.application\nimport bokeh.application.handlers\nimport bokeh.models\n\n\nimport holoviews as hv\n\nbokeh.io.output_notebook()\nhv.extension('bokeh')\n\n# %% [markdown]\n#  Let's load the data from the relevant folder. If this data doesn't exist for you, you'll need to run the `processing/raw_data_processing/daily_refresh.sh` script (which may require `pip install us`).\n\n# %%\nimport git\n\nrepo = git.Repo(\"./\", search_parent_directories=True)\nhomedir = repo.working_dir\ndatadir = f\"{homedir}/data/us/\"\n\n# %% [markdown]\n#  Load the US data by state (50 states, but we also make a bunch of other countries pay taxes without getting the right to vote (Puerto Rico, Guam, etc.), so we include their data too).\n#  This results in more than 50 \"regions\".\n\n# %%\ndf = pd.read_csv(datadir + 'covid/nyt_us_states.csv')\n\n# %% [markdown]\n# We want to count days as integers from some starting point.\n\n# %%\ndf['date_processed'] = pd.to_datetime(df['date'].values)\ndf['date_processed'] = (df['date_processed'] - df['date_processed'].min()) / np.timedelta64(1, 'D')\n\n# %% [markdown]\n# Now we import the population for each state, and add that information correctly to the Pandas \"dataframe\".\n\n# %%\npopulations = pd.read_csv(datadir + 'demographics/state_populations_augmented.csv')\ndef get_population(region):\n    return populations[populations['state'] == region]['population'].values[0]\n\ndef get_ticker(state):\n    state_to_ticker = dict([('CA','California'),('TX','Texas'),('FL','Florida'),('NY','New York'),('PA','Pennsylvania'),('IL','Illinois'),('OH','Ohio'),('GA','Georgia'),('NC','North Carolina'),\n                           ('MI','Michigan'),('NJ','New Jersey'),('VA','Virginia'),('WA','Washington'),('AZ','Arizona'),('MA','Massachusetts'),('TN','Tennessee'),('IN','Indiana'),('MO','Missouri'),\n                           ('MD','Maryland'),('WI','Wisconsin'),('CO','Colorado'),('MN','Minnesota'),('SC','South Carolina'),('AL','Alabama'),('LA','Louisiana'),('KY','Kentucky'),('OR','Oregon'),\n                           ('OK','Oklahoma'),('CT','Connecticut'),('UT','Utah'),('IA','Iowa'),('NV','Nevada'),('AR','Arkansas'),('MS','Mississippi'),('KS','Kansas'),('NM','New Mexico'),('NE','Nebraska'),\n                           ('WV','West Virginia'),('ID','Idaho'),('HI','Hawaii'),('NH','New Hampshire'),('ME','Maine'),('MT','Montana'),('RI','Rhode Island'),('DE','Delaware'),('SD','South Dakota'),\n                           ('ND','North Dakota'),('AK','Alaska'),('DC','District of Columbia'),('VT','Vermont'),('WY','Wyoming'),('PR','Puerto Rico'),('VI','Virgin Islands'),('GU','Guam'),\n                           ('NMI','Northern Mariana Islands')])\n    state_to_ticker = {v: k for k, v in state_to_ticker.items()} # I accidentally typed the dictionary backwards (:\n    return state_to_ticker[state]\n\n# %% [markdown]\n# Let's also include the state ticker (i.e. Minnesota --> MN) as a column in the Pandas dataframe. (Because the US population info is given by state tickers).\n\n# %%\ndf['state_ticker'] = df.apply(lambda row: get_ticker(row.state),axis = 1)\ndf['Population'] = df.apply(lambda row: get_population(row.state_ticker), axis=1)\n\n# %% [markdown]\n#  Just checking to make sure the data is here...\n\n# %%\ndf.head()\n\n# %% [markdown]\n#  Great! Let's also make a helper function to select data from a state, starting when the pandemic hit to be able to fit models. \n#  \n#  We could change the parameter \"min_deaths\" here if we want... it seems like an arbitrary choice.\n\n# %%\n# return data ever since first min_cases cases\ndef select_region(df, region, min_deaths=50):\n    d = df.loc[df['state'] == region]\n    start = np.where(d['deaths'].values > min_deaths)[0][0]\n    d = d[start:]\n    return d\n\n# %% [markdown]\n#  ## MODEL 1 of 3: erf model\n# %% [markdown]\n#  Let's start with a simple model used in this major paper by IHME: https://www.medrxiv.org/content/10.1101/2020.03.27.20043752v1. Just fit an erf function, nothing else.\n\n# %%\nfrom scipy.special import erf\nfrom scipy.optimize import curve_fit\n\ndef erf_curve(t, logp, a, b):\n    p = 10**logp\n    deaths = p/2*(1+erf(a*(t-b)))\n    return deaths\n\ndef erf_model(params, data, future=0):\n    # initial conditions\n    p = 10**params[0]\n    a = params[1]\n    b = params[2]\n    \n    t = data['date_processed'].values\n    if future > 0:\n        extrapolation = np.arange(future)\n        t = np.concatenate((t, extrapolation + t[-1] + 1))\n    deaths = p/2*(1+erf(a*(t-b)))\n    \n    return t, deaths\n\ndef erf_fit(params, data):\n    Draw = data['deaths'].values\n    Draw[np.where(Draw < 1)] = 1\n    Ddata = Draw\n    t, Draw = erf_model(params, data)\n    Draw[np.where(Draw < 1)] = 1\n    D = Draw\n    \n    error = mse(D, Ddata)\n    \n    return error\n\n# %% [markdown]\n#  Now let's try to have something to run the fit and plot the results, including a prediction. To estimate errors, we'll use `curve_fit` and the covariance matrix it returns. Sampling parameters from a Gaussian distribution around the fit, we then bootstrap errors corresponding to 25th and 75th percentile predictions.\n# \n#  Maybe we can change the way that the quantile predictions are made. The quantile predictions get crazy later (~1e150, which is way to fucking big).\n\n# %%\nfrom bokeh.models import Span\n\ndef plot_erf_with_errors_sample(df, region, extrapolate=1, boundary=None):\n    '''\n    df: main italy data frame\n    region: string (region name)\n    extrapolate: run model on this * length of data (ex. extrapolate=1 does no prediction, extrapolate=2 predicts a time interval equal in length to the data length)\n    boundary: train model on data until the day demarcated by boundary; if boundary is None, train on all available data\n    '''\n    data = select_region(df, region)\n    keys = ['deaths', 'cases']\n    all_out = []\n    proper = []\n    for k in keys:\n        erf_params0 = [np.log10(np.max(data[k])), .1, 30]\n        y = data[k].values[:boundary]\n        popt, pcov = curve_fit(erf_curve, data['date_processed'].values[:boundary], y, p0=erf_params0)\n        errors = np.sqrt(np.diag(pcov))\n        #======BEGIN=======DEBUGGING================================================================================\n        if k == 'deaths':\n            print('popt = ', popt)\n            print('errors = ', errors)\n        #========END=========DEBUGGING================================================================================\n        all_s = []\n        samples = 100\n        for i in range(samples):\n            sample = np.random.normal(loc=popt, scale=errors)\n            t, y = erf_model(sample, data, future=len(data)*(extrapolate-1))\n            all_s.append(y)\n        \n        all_s = np.array(all_s)\n        all_out.append(all_s)\n        \n        t, y = erf_model(popt, data, future=len(data)*(extrapolate-1))\n        proper.append(y)\n    \n    t = np.arange(0, len(data))\n    tp = np.arange(0, len(data)*extrapolate)\n\n    p = bokeh.plotting.figure(plot_width=600,\n                              plot_height=400,\n                             title = region + ' erf Model',\n                             x_axis_label = 't (days)',\n                             y_axis_label = '# people')\n\n    p1 = 25\n    p2 = 75\n    p.varea(x=tp, y1=np.percentile(all_out[1], p1, axis=0), y2=np.percentile(all_out[1], p2, axis=0), color='purple', fill_alpha=0.2)\n    p.varea(x=tp, y1=np.percentile(all_out[0], p1, axis=0), y2=np.percentile(all_out[0], p2, axis=0), color='black', fill_alpha=0.2)\n    \n#     s1 = np.percentile(all_s, 40, axis=0)\n#     s2 = np.percentile(all_s, 60, axis=0)\n#     p.varea(x=tp, y1=s1[:, 2], y2=s2[:, 2], color='red', fill_alpha=0.2)\n#     p.varea(x=tp, y1=s1[:, 3], y2=s2[:, 3], color='purple', fill_alpha=0.2)\n#     p.varea(x=tp, y1=s1[:, 5], y2=s2[:, 5], color='black', fill_alpha=0.2)\n    \n    p.line(tp, proper[0], color = 'black', line_width = 1, legend_label = 'Deceased')\n    p.line(tp, proper[1] , color = 'purple', line_width = 1, legend_label = 'Symptomatic infected')\n\n    # deaths\n    p.circle(t, data[keys[0]], color ='black')\n\n    # cases\n    p.circle(t, data[keys[1]], color ='purple')\n    \n    if boundary is not None and boundary < len(data):\n        vline = Span(location=boundary, dimension='height', line_color='black', line_width=3)\n        p.renderers.extend([vline])\n\n    p.legend.location = 'top_left'\n    bokeh.io.show(p)\n\n# %% [markdown]\n#  And how well does this model do at prediction? We train it on days 0-16 (left of the vertical line), and we try to predict days afterwards.\n\n# %%\nplot_erf_with_errors_sample(df, 'Washington', 2, 10)\n\n# %% [markdown]\n#  Hm. Let's check how it performs more systematically. Let's try adjusting how long we train and predict for.\n# \n#  There is obviously some kind of fitting error that's happening here. But I don't care that much because the erf model is not even a great model.\n\n# %%\nstart = 12\nstep = 4\nind = 0\nresults = []\none_more = False\nwhile start + ind*step <= 18:\n    boundary = start + ind*step\n    plot_erf_with_errors_sample(df, 'Washington', 2, boundary)\n    ind += 1\n\n# %% [markdown]\n#  The model seems to think that the pandemic will flatten out in the next couple days. Given the earlier plots, I doubt that is right. We can check it on another region and see what happens! What regions can we choose from? We need a region with enough data.\n\n# %%\nregions = sorted(np.unique(df['state'].values)) # this is just alphabetical\nprint(regions)\nfor r in regions:\n    print(r + ' has ',[np.amax(df.loc[df['state'] == r]['cases'].values)], ' cases')\n\n# %% [markdown]\n#  The predictions look a little better for Emilia Romagna, but it appears that the error bars for anything earlier than 16-day prediction are enormous. By the time you reach 20 days, however, we only have 22 days of data, so it seems a little trivial to predict.\n\n# %%\n# start = 16\n# step = 4\n# ind = 0\n# results = []\n# one_more = False\n# while start + ind*step <= 24:\n#     boundary = start + ind*step\n#     plot_erf_with_errors_sample(df, 'Alabama', 2, boundary)\n#     ind += 1\n\n# %% [markdown]\n#  Time to move on to a more standard epidemiological model.\n# %% [markdown]\n#  ## MODEL 2 of 3: SEIR-QD model\n# %% [markdown]\n#  Ok, will this model isn't too standard. It's selected as one of the best-performing models from \"Rational evaluation of various epidemic models based on the COVID-19 data of China\" (https://www.medrxiv.org/content/10.1101/2020.03.12.20034595v1.full.pdf), where it turned out to be one of the better models in terms of early-stage data collection. It takes into effect quarantine and self-protection, but not from data; it just makes assumptions about how people behave. The differential equations can be found on page 8 of the supplement: https://www.medrxiv.org/content/medrxiv/suppl/2020/03/16/2020.03.12.20034595.DC1/2020.03.12.20034595-1.pdf. Thanks @Liana Merk for doing the initial work on this model!\n# \n#  Parameters:\n#  * $\\beta$ = infection rate, from earlier plotting, $10^{(-8)} - 10^{(-6)}$ seem reasonable.\n#  * $\\delta$ = recovery rate, which we think is on the order of 10-40 days.\n#  * $\\gamma$ = transition of exposed individuals to infected, which we aren't sure of, especially with the unknown number of asymptomatics.\n#  * $\\alpha$ = protection rate of susceptible individuals, which we also don't know, and is most likely dynamic over the course of the outbreak.\n#  * $\\lambda$ = transition rate of infected to quarantined with infection, same as above.\n#  * $\\kappa$ = death rate, which we think is around 0.01-0.06. We will leave a range between 0.01 and 0.1.\n\n# %%\ndef seirqd(dat, t, params, N):\n    beta = params[0] / N\n    delta = params[1]\n    gamma = params[2]\n    alpha = params[3]\n    lambda_ = params[4]\n    kappa = params[5]\n    \n    s = dat[0]\n    e = dat[1]\n    i = dat[2]\n    q = dat[3]\n    r = dat[4]\n    d = dat[5]\n    sa = dat[6]\n    \n    dsdt = - beta * s * i - alpha * s\n    dedt = beta * s * i - gamma * e\n    didt = gamma * e - lambda_ * i\n    dqdt = lambda_ * i - delta * q - kappa * q\n    drdt = delta * q\n    dddt = kappa * q\n    dsadt = alpha * s\n    \n    # susceptible, exposed, infected, quarantined, recovered, died, unsusceptible\n    return [dsdt, dedt, didt, dqdt, drdt, dddt, dsadt]\n\n\n# %%\nfrom sklearn.metrics import mean_squared_error\n\ndef mse_qd(A, B):\n    Ap = np.nan_to_num(A)\n    Bp = np.nan_to_num(B)\n    Ap[A == -np.inf] = 0\n    Bp[B == -np.inf] = 0\n    Ap[A == np.inf] = 0\n    Bp[B == np.inf] = 0\n    return mean_squared_error(Ap, Bp)\n\ndef model_qd(params, data, tmax=-1):\n    # initial conditions\n    N = data['Population'].values[0] # total population\n    initial_conditions = N * np.array(params[-5:]) # the parameters are a fraction of the population so multiply by the population\n    \n    # initial conditions\n    e0 = initial_conditions[0]\n    i0 = initial_conditions[1]\n    q0 = initial_conditions[2]\n    r0 = initial_conditions[3]\n    sa0 = initial_conditions[4]\n    \n    d0 = data['deaths'].values[0]\n    s0 = N - np.sum(initial_conditions) - d0\n\n    yz_0 = np.array([s0, e0, i0, q0, r0, d0, sa0])\n    \n    # Package parameters into a tuple\n    args = (params, N)\n    \n    n = len(data)\n    if tmax > 0:\n        n = tmax\n    \n    # Integrate ODEs\n    s = scipy.integrate.odeint(seirqd, yz_0, np.arange(0, n), args=args)\n\n    return s\n\ndef fit_leastsq_qd(params, data):\n    Ddata = (data['deaths'].values)\n    Idata = (data['cases'].values)\n    s = model_qd(params, data)\n\n    S = s[:,0]\n    E = s[:,1]\n    I = s[:,2]\n    Q = s[:,3]\n    R = s[:,4]\n    D = s[:,5]\n    SA = s[:,6]\n    \n    error = np.concatenate((D-Ddata, I - Idata))\n    return error\n\n# %% [markdown]\n#  Let's check if this is reasonable with a manual fit to the US state of Washington. Anyway, we need to provide the optimization method an initial guess of the parameters, so this gives us a good chance to make a reasonable guess and speed up the optimization. Some good guesses are provided by the SEIR model here: https://gabgoh.github.io/COVID/index.html.\n# \n#  NOT SURE WHY THIS FIT DOESN'T WORK WELL\n\n# %%\nget_ipython().run_line_magic('matplotlib', 'notebook')\nget_ipython().run_line_magic('matplotlib', 'inline')\n\nplt.figure()\nd = select_region(df, 'Washington')\n# parameters: beta, delta, gamma, alpha, lambda, kappa\nparams = [2.0, 0.3, 0.2, 0.05, 0.2, 0.03]\n# parameters: beta, sigma, ra, shift\n# params = [1.1, 0.8, 0.2, 0.3]\n# conditions: E, I, Q, R, SA\ninitial_conditions = [0.5e-3, 0.5e-3, 0.3e-3, 0.1e-4, 0.5]\ns = model_qd(params + initial_conditions, d, False)\nplt.scatter(d['date_processed'], d['deaths'])\nplt.plot(d['date_processed'], s[:, 5])\nplt.show()\n\nprint('Do the initial conditions sum to one? If not, what do they physically mean?')\nprint('They sum to ',sum(initial_conditions))\n\n# %% [markdown]\n#  Looks good! How about actually fitting it now? We need a plotting function!\n# \n#  ^ DOES NOT LOOK GOOD! LOOKS BAD! Do we need to change the initial conditions? This model ends up working later, so something must change to make it work for the state of Washington.\n\n# %%\nimport itertools\n\ndef plot_qd(res, p0_params, p0_initial_conditions, df, region, extrapolate=1, boundary=None, plot_infectious=False):\n    data = select_region(df, region)\n    \n    s = model_qd(res.x, data, len(data)*extrapolate)\n    S = s[:,0]\n    E = s[:,1]\n    I = s[:,2]\n    Q = s[:,3]\n    R = s[:,4]\n    D = s[:,5]\n    SA = s[:,6]\n\n    t = np.arange(0, len(data))\n    tp = np.arange(0, len(data)*extrapolate)\n\n    p = bokeh.plotting.figure(plot_width=600,\n                              plot_height=400,\n                             title = region + ' SEIIRD+Q Model',\n                             x_axis_label = 't (days)',\n                             y_axis_label = '# people')\n\n    if plot_infectious:\n        p.line(tp, I, color = 'red', line_width = 1, legend_label = 'All infected')\n    p.line(tp, D, color = 'black', line_width = 1, legend_label = 'Deceased')\n\n    # death\n    p.circle(t, data['deaths'], color ='black')\n\n    # quarantined\n    p.circle(t, data['cases'], color ='purple', legend_label='Tested infected')\n    \n    if boundary is not None:\n        vline = Span(location=boundary, dimension='height', line_color='black', line_width=3)\n        p.renderers.extend([vline])\n\n    p.legend.location = 'top_left'\n    bokeh.io.show(p)\n\n# %% [markdown]\n#  We'll need to estimate errors from the optimization procedure. I transferred some of the relevant code from `curve_fit` to work for this kind of model:\n\n# %%\nfrom scipy.linalg import svd\n# return params, 1 standard deviation errors\ndef get_errors(res, p0):\n    p0 = np.array(p0)\n    ysize = len(res.fun)\n    cost = 2 * res.cost  # res.cost is half sum of squares!\n    popt = res.x\n    # Do Moore-Penrose inverse (Pseudoinverse) discarding zero singular values.\n    _, s, VT = svd(res.jac, full_matrices=False)\n    threshold = np.finfo(float).eps * max(res.jac.shape) * s[0]\n    s = s[s > threshold]\n    VT = VT[:s.size]\n    pcov = np.dot(VT.T / s**2, VT)\n\n    warn_cov = False\n    absolute_sigma = False\n    if pcov is None:\n        # indeterminate covariance\n        pcov = zeros((len(popt), len(popt)), dtype=float)\n        pcov.fill(inf)\n        warn_cov = True\n    elif not absolute_sigma:\n        if ysize > p0.size:\n            s_sq = cost / (ysize - p0.size)\n            pcov = pcov * s_sq\n        else:\n            pcov.fill(inf)\n            warn_cov = True\n\n    if warn_cov:\n        print('cannot estimate variance')\n        return None\n    \n    perr = np.sqrt(np.diag(pcov))\n    return perr\n\n# %% [markdown]\n#  To do the optimization, we should define reasonable ranges for the parameters as well.\n\n# %%\nparam_ranges = [(0.5, 3.0), (0.0, 0.5), (0.0, 0.5), (0.01, 0.5), (0.0, 0.5), (0.005, 0.1)]\ninitial_ranges = [(1.0e-7, 0.01), (1.0e-7, 0.01), (1.0e-7, 0.01), (1.0e-7, 0.01), (1.0e-7, 0.9)]\nguesses = params + initial_conditions\nranges = param_ranges + initial_ranges\n\n\n# %%\nfrom scipy.optimize import least_squares\nres = least_squares(fit_leastsq_qd, guesses, args=(select_region(df, 'Wisconsin'),), bounds=np.transpose(np.array(ranges)))\n\n\n# %%\nplot_qd(res, params, initial_conditions, df, 'Wisconsin', extrapolate=2, plot_infectious=True)\n\n# %% [markdown]\n#  This is quite misleading! We don't actually know how many people are infected, so this model isn't quite what we're looking for. Instead, we only know the people who were tested as infected; they usually have symptoms. I won't bother with the error analysis for this model, but we can see how it holds up to prediction.\n# \n#  HERE THE MODEL FINALLY WORKS FOR US DATA (Washington). Note that initial conditions are given here. I'm not sure where they got the initial conditions, but in the code, they are defined 5 or 6 cells above.\n\n# %%\nstart = 10\nstep = 4\nind = 0\nresults = []\none_more = False\nwhile start + ind*step <= 18:\n    boundary = start + ind*step\n    res = least_squares(fit_leastsq_qd, guesses, args=(select_region(df, 'New York')[:boundary],), bounds=np.transpose(np.array(ranges)))\n    plot_qd(res, params, initial_conditions, df, 'New York', extrapolate=2, boundary=boundary, plot_infectious=True)\n    ind += 1\n\n# %% [markdown]\n#  Despite being conceptually wrong, this produces much more satisfactory predictions of fatality rates than the erf model. The infectious predictions should be taken with a (very large) grain of salt anyway, since we know it isn't really predicting the infected population.\n# %% [markdown]\n#  ## MODEL 3 of 3: $\\mathbf{SEI_A I_S R}$ with empirical quarantine\n# %% [markdown]\n#  The motivation for this model is to add two crucial ingredients: quarantine data and asymptomatic cases. For quarantine analysis, we find an effective population size based on what fraction of the population is moving according to https://citymapper.com/cmi/milan. (Since Milan is the capital of Lombardy, we perform the analysis for that region.) To make the quarantine more realistic, we model a \"leaky\" quarantine, where the susceptible population is given by the mobility from above plus some offset. To treat asymptomatic cases, we introduce states $I_A$ (asymptomatic) and $I_S$ (symptomatic) according to the following sketch and differential equations:\n# %% [markdown]\n#  ![SEIIR + quarantine](images/overview.png)\n# %% [markdown]\n#  Since this is prototyping the model, we manually enter the chart above (raw data is at the link above) and implement it. We also have a testing function $T(t)$ (called `tau(t)` in the code) that allows us to try out different testing strategies for asymptomatic populations. Sorry about the confusing variable names below: parameters are renamed as $\\sigma\\to$ `alpha`, $s\\to$ `sigma`, and $d\\to$ `delta`. Not shown in the equations above but included in the diagram is a fixed offset (`offset`) for the leaky quarantine model.\n# \n#  ***Regarding \"TODO fix data imputation\", we need to somehow get this data based on US states. Currently, the mobility data (and therefore quarantine data) is hard coded into the vector 'moving'. I'm not sure what shift is. Some arbitrary parameter that probably also needs to be fit...\n\n# %%\n# TODO fix data imputation\ndef q(t, N, shift):\n    moving = np.array([57, 54, 52, 51, 49, 47, 46, 45, 44, 43, 39, 37, 34, 23, 19, 13, 10, 7, 6, 5, 5, 7, 6, 5, 4, 4, 3, 3, 4, 4, 3, 3, 3, 3, 2])/100 \n    q = N*(1-moving) - shift*N\n    if np.round(t) >= len(q):\n        return q[-1]\n    return q[int(np.round(t))]\n    \ndef tau(t):\n    return 0\n\ndef seiirq(dat, t, params, N, max_t, offset):\n    if t >= max_t:\n        return [0]*8\n    beta = params[0]\n    alpha = params[1] # rate from e to ia\n    sigma = params[2] # rate of asymptomatic people becoming symptotic\n    ra = params[3] # rate of asymptomatic recovery\n    rs = params[4] # rate of symptomatic recovery\n    delta = params[5] # death rate\n    shift = params[6] # shift quarantine rate vertically from CityMapper data\n    \n    s = dat[0]\n    e = dat[1]\n    i_a = dat[2]\n    i_s = dat[3]\n\n    Qind = (q(t + offset, N, shift) - tau(t + offset)*i_a)/(s + e + i_a - tau(t + offset)*i_a)\n    Qia = Qind + (1-Qind)*tau(t + offset)\n    \n    dsdt = - beta * s * i_a * (1 - Qind) * (1 - Qia) / N\n    dedt = beta * s * i_a* (1 - Qind) * (1 - Qia) / N  - alpha * e\n    diadt = alpha * e - (sigma + ra) * i_a\n    disdt = sigma * i_a - (delta + rs) * i_s\n    dddt = delta * i_s\n    drdt = ra * i_a + rs * i_s\n    \n    \n    # susceptible, exposed, infected, quarantined, recovered, died, unsusceptible\n    out = [dsdt, dedt, diadt, disdt, drdt, dddt]\n    return out\n\n\n# %%\nfrom sklearn.metrics import mean_squared_error\n\ndef mse(A, B):\n    Ap = np.nan_to_num(A)\n    Bp = np.nan_to_num(B)\n    Ap[A == -np.inf] = 0\n    Bp[B == -np.inf] = 0\n    Ap[A == np.inf] = 0\n    Bp[B == np.inf] = 0\n    return mean_squared_error(Ap, Bp)\n\ndef model_z(params, data, tmax=-1):\n    # initial conditions\n    N = data['Population'].values[0] # total population\n    initial_conditions = N * np.array(params[-4:]) # the parameters are a fraction of the population so multiply by the population\n    \n    e0 = initial_conditions[0]\n    ia0 = initial_conditions[1]\n    is0 = initial_conditions[2]\n    r0 = initial_conditions[3]\n    \n    d0 = data['deaths'].values[0]\n    s0 = N - np.sum(initial_conditions) - d0\n\n    offset = data['date_processed'].min()\n    yz_0 = np.array([s0, e0, ia0, is0, r0, d0])\n    \n    n = len(data)\n    if tmax > 0:\n        n = tmax\n    \n    # Package parameters into a tuple\n    args = (params, N, n, offset)\n    \n    # Integrate ODEs\n    try:\n        s = scipy.integrate.odeint(seiirq, yz_0, np.arange(0, n), args=args)\n    except RuntimeError:\n#         print('RuntimeError', params)\n        return np.zeros((n, len(yz_0)))\n\n    return s\n\ndef fit_leastsq_z(params, data):\n    Ddata = (data['deaths'].values)\n    Idata = (data['cases'].values)\n    s = model_z(params, data)\n\n    S = s[:,0]\n    E = s[:,1]\n    I_A = s[:,2]\n    I_S = s[:,3]\n    R = s[:,4]\n    D = s[:,5]\n    \n    error = np.concatenate(((D-Ddata), I_S - Idata))\n    return error\n\n# %% [markdown]\n#  Again, we find some good initial parameters.\n# \n#  *** We need to find some good initial parameters. ):\n\n# %%\nget_ipython().run_line_magic('matplotlib', 'notebook')\nget_ipython().run_line_magic('matplotlib', 'inline')\n\nplt.figure()\nd = select_region(df, 'Washington')\n# parameters: beta, alpha, sigma, ra, rs, delta, shift\nparams = [1.8, 0.35, 0.1, 0.15, 0.34, 0.015, 0.5]\n# conditions: E, IA, IS, R\ninitial_conditions = [4e-6, 0.0009, 0.0005, 0.0002]\ns = model_z(params + initial_conditions, d)\nplt.scatter(d['date_processed'], d['deaths'])\nplt.plot(d['date_processed'], s[:, 5])\nplt.show()\n\n\n# %%\nimport itertools\n\ndef plot_with_errors_sample_z(res, p0_params, p0_initial_conditions, df, region, extrapolate=1, boundary=None, plot_infectious=False):\n    data = select_region(df, region)\n    errors = get_errors(res, list(p0_params) + list(p0_initial_conditions))\n    errors[len(p0_params):] = 0\n    \n    all_s = []\n    samples = 100\n    for i in range(samples):\n        sample = np.random.normal(loc=res.x, scale=errors)\n        s = model_z(sample, data, len(data)*extrapolate)\n        all_s.append(s)\n        \n    all_s = np.array(all_s)\n    \n    s = model_z(res.x, data, len(data)*extrapolate)\n    S = s[:,0]\n    E = s[:,1]\n    I_A = s[:,2]\n    I_S = s[:,3]\n    R = s[:,4]\n    D = s[:,5]\n\n    t = np.arange(0, len(data))\n    tp = np.arange(0, len(data)*extrapolate)\n\n    p = bokeh.plotting.figure(plot_width=600,\n                              plot_height=400,\n                             title = region + ' SEIIRD+Q Model',\n                             x_axis_label = 't (days)',\n                             y_axis_label = '# people')\n\n    s1 = np.percentile(all_s, 25, axis=0)\n    s2 = np.percentile(all_s, 75, axis=0)\n    if plot_infectious:\n        p.varea(x=tp, y1=s1[:, 2], y2=s2[:, 2], color='red', fill_alpha=0.2)\n    p.varea(x=tp, y1=s1[:, 3], y2=s2[:, 3], color='purple', fill_alpha=0.2)\n    p.varea(x=tp, y1=s1[:, 5], y2=s2[:, 5], color='black', fill_alpha=0.2)\n    \n    if plot_infectious:\n        p.line(tp, I_A, color = 'red', line_width = 1, legend_label = 'Asymptomatic infected')\n    p.line(tp, D, color = 'black', line_width = 1, legend_label = 'Deceased')\n    p.line(tp, I_S , color = 'purple', line_width = 1, legend_label = 'Symptomatic infected')\n\n    # death\n    p.circle(t, data['deaths'], color ='black')\n\n    # quarantined\n    p.circle(t, data['cases'], color ='purple')\n    \n    if boundary is not None:\n        vline = Span(location=boundary, dimension='height', line_color='black', line_width=3)\n        p.renderers.extend([vline])\n\n    p.legend.location = 'top_left'\n    bokeh.io.show(p)\n    return all_s,s1,s2\n\n# %% [markdown]\n#  Let's define the initial ranges of the constants for the ODE.\n\n# %%\n# beta, alpha, sigma, ra, rs, delta, shift\nparam_ranges = [(1.0, 2.0), (0.1, 0.5), (0.1, 0.5), (0.05, 0.5), (0.32, 0.36), (0.005, 0.05), (0.1, 0.6)]\ninitial_ranges = [(1.0e-7, 0.001), (1.0e-7, 0.001), (1.0e-7, 0.001), (1.0e-7, 0.001)]\n\nguesses = params + initial_conditions\nranges = param_ranges + initial_ranges\n\n\n# %%\n# beta, alpha, sigma, ra, rs, delta, shift\nparam_ranges = [(1.0, 2.0), (0.1, 0.5), (0.1, 0.5), (0.05, 0.5), (0.32, 0.36), (0.005, 0.05), (0.1, 0.6)]\ninitial_ranges = [(1.0e-7, 0.001), (1.0e-7, 0.001), (1.0e-7, 0.001), (1.0e-7, 0.001)]\n\nguesses = params + initial_conditions\nranges = param_ranges + initial_ranges\n\nboundary = 16\nres = least_squares(fit_leastsq_z, guesses, args=(select_region(df, 'Washington')[:boundary],), bounds=np.transpose(np.array(ranges)),jac = '3-point')\nall_s,s1,s2 = plot_with_errors_sample_z(res, params, initial_conditions, df, 'Washington', extrapolate=1, boundary=boundary, plot_infectious=True)\nperr = get_errors(res,np.zeros((11,1)))\nprint('parameter standard deviations = ',perr)\n\n\n# %%\nstart = 8\nstep = 4\nind = 0\nresults = []\none_more = False\nwhile start + ind*step <= 18:\n    boundary = start + ind*step\n    res = least_squares(fit_leastsq_z, guesses, args=(select_region(df, 'Washington')[:boundary],), bounds=np.transpose(np.array(ranges)),jac = '3-point')\n    plot_with_errors_sample_z(res, params, initial_conditions, df, 'Washington', extrapolate=1, boundary=boundary, plot_infectious=True)\n    ind += 1\n\n# %% [markdown]\n# ***HUUUUGE uncertainty bars. Need to figure out why. Maybe because we don't have good fit parameters, so the covariance is huge.\n# \n# \n#  Just like SEIR-QD, the predictions of cases aren't so great, although the predictions of fatalaties (which matters more and has less data bias) is reasonably accurate. The model also produces prediction that around 2/3 of the cases are asymptomatic (or at least not tested). This corresponds roughly to some recent studies, such as the 50-75% number reported after testing an entire town of 3,300 in Italy (https://www.repubblica.it/salute/medicina-e-ricerca/2020/03/16/news/coronavirus_studio_il_50-75_dei_casi_a_vo_sono_asintomatici_e_molto_contagiosi-251474302/?ref=RHPPTP-BH-I251454518-C12-P3-S2.4-T1) and similar results in Iceland (https://www.government.is/news/article/2020/03/15/Large-scale-testing-of-general-population-in-Iceland-underway/).\n\n# %%\n\n\n", "meta": {"hexsha": "8137b676d78e5edeb65a95a3422777c7f69bc33e", "size": 29545, "ext": "py", "lang": "Python", "max_stars_repo_path": "ALEX/baseline.py", "max_stars_repo_name": "aco8ogren/Tentin-Quarantino", "max_stars_repo_head_hexsha": "08b494f5deb2c33e3bb5981135c780b0a34d5557", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ALEX/baseline.py", "max_issues_repo_name": "aco8ogren/Tentin-Quarantino", "max_issues_repo_head_hexsha": "08b494f5deb2c33e3bb5981135c780b0a34d5557", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ALEX/baseline.py", "max_forks_repo_name": "aco8ogren/Tentin-Quarantino", "max_forks_repo_head_hexsha": "08b494f5deb2c33e3bb5981135c780b0a34d5557", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.1324503311, "max_line_length": 755, "alphanum_fraction": 0.6390929091, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 8647, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49218813572079556, "lm_q2_score": 0.1259227615549033, "lm_q1q2_score": 0.06197768925452213}}
{"text": "import numpy as np\n\nimport matplotlib\nimport matplotlib.pyplot as plt\nfrom matplotlib import rcParams\nfrom mpl_toolkits.mplot3d import Axes3D\n\nimport ipywidgets as widgets\nfrom ipywidgets import AppLayout, FloatSlider\nfrom ipywidgets import GridspecLayout\nfrom matplotlib import rc\n\nfrom copy import deepcopy\n\ntry:\n    from addict import Dict \nexcept:\n    import subprocess\n    import sys\n    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"addict\"])\n    from addict import Dict \n\ntry:\n    import ipympl\nexcept:\n    import subprocess\n    import sys\n    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ipympl\"])\n    install(\"ipympl\")\n    \n    \ndef dict_merge(destination, source):\n    out = deepcopy(destination)\n    for key, value in source.items():\n        if isinstance(value, dict):\n            # get node or create one\n            node = out.setdefault(key, {})\n            dict_merge(node, value)\n        else:\n            out[key] = value\n    return out\n\nPARAM = Dict()\nPARAM.background_color = (0.0, 0.0, 0.0, 0.0)  \nPARAM.zlim = (-4,4)\nPARAM.grid_color = (0.0, 0.0, 0.0, 0.25)\nPARAM.grid_linewidth = 0.25\nPARAM.grid_size = 20\nPARAM.border_color = (0.0, 0.0, 0.0, 0.25)\nPARAM.border_linewidth = 0.25\nPARAM.tick_color = (0.0, 0.0, 0.0, 0.25)\nPARAM.tick_linewidth = 0.25\nPARAM.label_size = 7\nPARAM.label_color = (0,0,0,1)\nPARAM.azimuth = -60\nPARAM.elevation = 30\nPARAM.header_visible = False\nPARAM.style = \"\"\nPARAM.plot_box = [[-2,2],[-2,2]]\nPARAM.cmap = plt.cm.jet\nPARAM.levels_number = 15\nPARAM.density = 0.5\nPARAM.iter_max = 40\n    \n\ndef set_axis3d(ax=None, **param):\n    # api for 3D plot : https://matplotlib.org/3.1.1/api/_as_gen/mpl_toolkits.mplot3d.axes3d.Axes3D.html\n    # last component is a level of gray : 0.0 for white to 1.0 for black\n    # https://matplotlib.org/_modules/mpl_toolkits/mplot3d/axes3d.html\n    \n    param = Dict(dict_merge(PARAM, param))\n    if ax is None:\n        ax = plt.axes(projection='3d')\n    \n    if param.style == \"raw\":\n        param.grid_color = (0.0, 0.0, 0.0, 0)\n        param.border_color = (0.0, 0.0, 0.0, 0)\n        param.tick_color = (0.0, 0.0, 0.0, 0)\n        ax.set_xticklabels([])\n        ax.set_yticklabels([])\n        ax.set_zticklabels([])\n    \n    # Now we apply the parameters:\n    \n    # Background of the plot\n    ax.w_xaxis.set_pane_color(param.background_color)\n    ax.w_yaxis.set_pane_color(param.background_color)\n    ax.w_zaxis.set_pane_color(param.background_color)\n\n    # Grid of the background\n    ax.xaxis._axinfo[\"grid\"]['color'] = param.grid_color\n    ax.yaxis._axinfo[\"grid\"]['color'] = param.grid_color\n    ax.zaxis._axinfo[\"grid\"]['color'] = param.grid_color\n    ax.xaxis._axinfo[\"grid\"]['linewidth'] = param.grid_linewidth\n    ax.yaxis._axinfo[\"grid\"]['linewidth'] = param.grid_linewidth\n    ax.zaxis._axinfo[\"grid\"]['linewidth'] = param.grid_linewidth\n\n    # Main axes (with the ticks labels etc) : \n    ax.w_xaxis.line.set_color(param.border_color) \n    ax.w_yaxis.line.set_color(param.border_color) \n    ax.w_zaxis.line.set_color(param.border_color)\n    ax.w_xaxis.line.set_linewidth(param.border_linewidth) \n    ax.w_yaxis.line.set_linewidth(param.border_linewidth) \n    ax.w_zaxis.line.set_linewidth(param.border_linewidth) \n\n    # Ticks\n    ax.tick_params(color=param.tick_color, \n                   size=param.tick_linewidth, # this is broken..\n                   axis='both', \n                   which='both', \n                   labelsize=param.label_size, \n                   labelcolor=param.label_color)\n    # other options : ['size', 'width', 'color', 'tickdir', 'pad', 'labelsize', 'labelcolor', 'zorder', 'gridOn', 'tick1On', 'tick2On', 'label1On', 'label2On', 'length', 'direction', 'left', 'bottom', 'right', 'top', 'labelleft', 'labelbottom', 'labelright', 'labeltop', 'labelrotation', 'grid_agg_filter', 'grid_alpha', 'grid_animated', 'grid_antialiased', 'grid_clip_box', 'grid_clip_on', 'grid_clip_path', 'grid_color', 'grid_contains', 'grid_dash_capstyle', 'grid_dash_joinstyle', 'grid_dashes', 'grid_data', 'grid_drawstyle', 'grid_figure', 'grid_fillstyle', 'grid_gid', 'grid_in_layout', 'grid_label', 'grid_linestyle', 'grid_linewidth', 'grid_marker', 'grid_markeredgecolor', 'grid_markeredgewidth', 'grid_markerfacecolor', 'grid_markerfacecoloralt', 'grid_markersize', 'grid_markevery', 'grid_path_effects', 'grid_picker', 'grid_pickradius', 'grid_rasterized', 'grid_sketch_params', 'grid_snap', 'grid_solid_capstyle', 'grid_solid_joinstyle', 'grid_transform', 'grid_url', 'grid_visible', 'grid_xdata', 'grid_ydata', 'grid_zorder', 'grid_aa', 'grid_c', 'grid_ds', 'grid_ls', 'grid_lw', 'grid_mec', 'grid_mew', 'grid_mfc', 'grid_mfcalt', 'grid_ms']\n    \n    # title and stuff around the plot\n    if \"title\" in param.keys():    \n        ax.title.set_text(param[\"title\"])\n    ax.view_init(param.elevation, param.azimuth)\n    \n    return ax\n    \n\ndef function_values(fun, **param):\n    # fun is a function taking two floats as an argument, returning one\n    if \"plot_box\" not in param.keys():\n        param[\"plot_box\"] = [[-2,2],[-2,2]]\n    if \"grid_size\" not in param.keys():\n        param[\"grid_size\"] = 20\n    \n    x = np.outer(np.linspace(param[\"plot_box\"][0][0], param[\"plot_box\"][0][1], param[\"grid_size\"]), np.ones(param[\"grid_size\"]))\n    y = np.outer(np.linspace(param[\"plot_box\"][1][0], param[\"plot_box\"][1][1], param[\"grid_size\"]), np.ones(param[\"grid_size\"])).T\n    \n    z = np.zeros((param[\"grid_size\"],param[\"grid_size\"]))\n    for idx, _ in np.ndenumerate(x):\n        z[idx] = fun(x[idx], y[idx])\n    return x, y, z\n\n\ndef field_values(fun, **param):\n    # fun is a function taking two floats as an argument, returning two\n    if \"plot_box\" not in param.keys():\n        param[\"plot_box\"] = [[-2,2],[-2,2]]\n    if \"grid_size\" not in param.keys():\n        param[\"grid_size\"] = 20\n    \n    x = np.outer(np.linspace(param[\"plot_box\"][0][0], param[\"plot_box\"][0][1], param[\"grid_size\"]), np.ones(param[\"grid_size\"]))\n    y = np.outer(np.linspace(param[\"plot_box\"][1][0], param[\"plot_box\"][1][1], param[\"grid_size\"]), np.ones(param[\"grid_size\"])).T\n    \n    zx = np.zeros((param[\"grid_size\"],param[\"grid_size\"]))\n    zy = np.zeros((param[\"grid_size\"],param[\"grid_size\"]))\n    for idx, _ in np.ndenumerate(x):\n        zx[idx], zy[idx] = fun(x[idx], y[idx])\n    return x, y, zx, zy\n\n\ndef matrix_definiteness(A):\n    if np.linalg.norm(A-A.T)> 1e-8 : # not symmetric\n        return matrix_definiteness(0.5*(A+A.T))\n    spec = np.linalg.eig(A)[0]\n    if (spec>0).all():\n        return \"Définie Positive\"\n    elif (spec>=0).all():\n        return \"Positive\"\n    elif (spec<0).all():\n        return \"Définie Négative\"\n    elif (spec<=0).all():\n        return \"Négative\"\n    else:\n        return \"Non Définie\"\n\ndef matrix_symmetricness(A):\n    if np.linalg.norm(A-A.T) < 1e-8:\n        return \"symétrique\"\n    elif np.linalg.norm(A+A.T) < 1e-8:\n        return \"antisymétrique\"\n    else:\n        return \"non symétrique\"\n\ndef print_info(A):\n    return \"La matrice A est \" + matrix_definiteness(A) + \", \" +  matrix_symmetricness(A)\n\n\ndef get_plots_we_want(**plot_param):\n    # what do we want to plot? Let's look at the parameters\n    possible_plots = [\"graph\", \"levelset\", \"gradient\", \"flow\"]\n    have_to_plot = {plot : ((plot in plot_param.keys()) and plot_param[plot]) for plot in possible_plots}# a dict with bool values\n    number_have_to_plot = sum(list(have_to_plot.values())) # number of Trues in the dict\n    \n    return have_to_plot, number_have_to_plot\n\n\ndef is_in_box(x, box):\n    return box[0][0] < x[0] < box[0][1] and box[1][0] < x[1] < box[1][1]\n\n\ndef sequence_gradient(func, x0=np.ones(2),stepsize=0.1,iter_max=100, **param):\n    # here func is a function with a gradient parameter\n    seq = []\n    x = x0\n    if 'plot_box' in param.keys() and is_in_box(x, param['plot_box']):\n        seq.append(x)\n    for t in range(iter_max):\n        grad = func(x[0], x[1], gradient=True) # grad is a tuple, we can compine it with arrays\n        x = x - stepsize*np.array(grad)\n        if 'plot_box' in param.keys():\n            # we check that the sequence is still within the bounds of our plot.\n            if is_in_box(x, param['plot_box']):\n                seq.append(x)\n        else:\n            seq.append(x)\n    X = [x[0] for x in seq]\n    Y = [x[1] for x in seq]\n    return X, Y\n\n\n\ndef quadratic(A, b=np.zeros(2), c=0):\n    # returns the function 0.5*<AX,X> + <b,X> + c or its gradient\n    def func(x,y, gradient=None):\n        if gradient is None:\n            return 0.5*( x*(A[0,0]*x + A[0,1]*y) + y*(A[1,0]*x + A[1,1]*y) ) + b[0]*x + b[1]*y + c\n        else:\n            AA = 0.5*(A + A.T)\n            return ( AA[0,0]*x + AA[0,1]*y + b[0], AA[1,0]*x + AA[1,1]*y + b[1] )\n    return func\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\ndef plot2d_function(func, fig=None, **plot_param):\n    \"\"\" Reprensents a func : (x,y) ---> z in various ways\n        If we ask for more than one representation, \n        they are all displayed next to each other in a subplot\n        \n    INPUT:\n      - fig : the handle of the figure in which drawing\n      - func : a function with the signature func(x,y,gradient) \n            func(x,y) returns the value of the function at (x,y)\n            func(x,y,gradient=True) returns the value of the \n            gradient at (x,y), as a 2-tuple\n        \n    OUTPUT: None\n        \n    OPTIONAL PARAMETERS: there is a *lot* of them, here are the main ones. default values\n        are stored in the PARAM dictionary\n      - cmap, colormap (plt.cm.jet) : the same colormap is used for every plot\n      - style, str (None) : \"raw\" plots naked graphs, without axis, background or ticks\n      - plot_box, 2D array ([[-2,2],[-2,2]]) : The syntax is [[xmin, xmax],[ymin,ymax]].\n            Defines the box in which all the objects will be plotted\n      \n      - graph, bool (False) : tells if plotting the 3D graph of the function. Displayed by default.\n          - grid_size, int (20) : Controls the precision of the mesh for plotting the graph.\n          - title, str (None) : A title to display on top of the graph\n      \n      - levelset, bool (False) : tells if plotting the 2D levelsets of the function\n          - levels, int (15) : number of levelsets to be displayed\n          \n      - gradient, bool (False) : tells if plotting the 2D vector field of the gradient of the function\n      \n      - flow, bool (False) : tells if plotting the descent gradient flow curves of the function\n          - density, float (0.5) : density of the flow curves. Impacts the performance.\n          \n      - sequence, (list,list) (None) : if a sequence is specified, it will be plotted on top of the 2D\n            graphs (levelset, gradient, flow). Impossible to plot it on 3D surfaces so far. \n            The syntax is : a 2-tuple, each component being a list of floats (same size) representing\n            the x- and y-coordinates of the sequence.\n      - algo, str (None) : instead of specifying a sequence, you can just pass an argument to tell\n            which algorithm you want to run on the function. Currently supported:\n          - \"gradient\" : Runs the gradient descent algorithm. You can pass options:\n              - x0, 1D arrray (np.ones(2)) : the initialization of the algorithm\n              - iter_max, int (100) : the maximum number of iterations allowed\n              - stepsize, float (0.1) : the stepsize in the iteration x <-- x - stepsize*gradient\n    \"\"\"\n    # deal with optional parameters\n    plot_param = Dict(dict_merge(PARAM, plot_param))\n    have_to_plot, number_plots = get_plots_we_want(**plot_param)\n    if fig is None:\n        fig = plt.gcf()\n    if 'algo' in plot_param.keys() and plot_param.algo is not None:\n        if plot_param.algo == 'gradient':\n            seq = sequence_gradient(func, **plot_param)\n            if len(seq[0]) == 0: # we are out ouf bounds\n                plot_param.sequence = None\n            else:\n                plot_param.sequence = seq\n                s = np.ones(len(plot_param.sequence[0]))*40\n                s[0] = 120\n                plot_param.scatter_size = s\n    fig.canvas.header_visible = plot_param.header_visible\n    \n    k = 0\n    if have_to_plot['graph']:\n        k = k+1\n        ax = fig.add_subplot(1, number_plots, k, projection='3d')\n        ax = set_axis3d(ax, **plot_param)\n        ax.plot_surface(*function_values(func, **plot_param), cmap=plot_param.cmap, rstride=1, cstride=1);\n        ax.set_zlim(plot_param.zlim);\n    if have_to_plot['levelset']:\n        k = k+1\n        ax = fig.add_subplot(1, number_plots, k)\n        contour = ax.contour(*function_values(func, **plot_param), cmap=plot_param.cmap, levels=plot_param.levels_number)\n        if plot_param[\"style\"] != \"raw\":\n            ax.clabel(contour, inline=1, fontsize=7);\n        else:\n            plt.axis('off')\n        if 'sequence' in plot_param.keys() and plot_param['sequence'] is not None:\n            ax.scatter(*plot_param['sequence'], s=plot_param.scatter_size)\n    if have_to_plot['gradient']:\n        k = k+1\n        ax = fig.add_subplot(1, number_plots, k)\n        X,Y,U,V = field_values(lambda x,y : func(x,y,gradient=True), **plot_param)\n        _,_,COLOR = function_values(func, **plot_param)\n        contour = ax.quiver(X,Y,U,V,COLOR, cmap=plot_param.cmap)\n        if plot_param[\"style\"] == \"raw\":\n            plt.axis('off')\n        if 'sequence' in plot_param.keys() and plot_param['sequence'] is not None:\n            ax.scatter(*plot_param['sequence'], s=plot_param.scatter_size)\n    if have_to_plot['flow']:\n        k = k+1\n        ax = fig.add_subplot(1, number_plots, k)\n        X,Y,U,V = field_values(lambda x,y : func(x,y,gradient=True), **plot_param)\n        _,_,COLOR = function_values(func, **plot_param)\n        # Here we need to TRANSPOSE the vector field because??? streamplot is stupid? arrays are indexed in a different way??\n        contour = ax.streamplot(X.T[0],Y[0],-U.T,-V.T, color=COLOR, density=plot_param.density, cmap=plot_param.cmap)\n        if plot_param[\"style\"] == \"raw\":\n            plt.axis('off')\n        if 'sequence' in plot_param.keys() and plot_param['sequence'] is not None:\n            ax.scatter(*plot_param['sequence'], s=plot_param.scatter_size)\n    #print(plot_param)\n    #return fig\n\n\n\n\n\ndef widget_quadratic(**plot_param):\n    # given a function handle (taking two arguments, returning one)\n    # plots an interactive widget with graph and level set\n    \n    # parameters for the plot\n    default_param = {\n        'plot_box' : [[-2,2],[-2,2]],\n        'grid_size' : 30,\n        'style' : \"normal\",\n        'dpi' : 80,\n        'sequence' : None,\n        'algo' : None\n    }\n    if get_plots_we_want(**plot_param)[1] == 0:\n        default_param['graph'] = True\n    plot_param = { **default_param, **plot_param }\n    dpi = plot_param['dpi']\n\n    # define all the sliders we want to manipulate\n    slider_param = {\n        'min' : -2, \n        'max' : 2,\n        'orientation' : 'horizontal',\n        #'layout' : Layout(height='auto', width='auto')#Layout(width='40%', margin='0px 30% 0px 30%'),\n    }\n    slider_a11 = FloatSlider(description='$A_{11}$', value=2.0, **slider_param)\n    slider_a12 = FloatSlider(description='$A_{12}$', value=0.0, **slider_param)\n    slider_a21 = FloatSlider(description='$A_{21}$', value=0.0, **slider_param)\n    slider_a22 = FloatSlider(description='$A_{22}$', value=1.0, **slider_param)\n    slider_b1  = FloatSlider(description='$b_1$', value=0.0, **slider_param)\n    slider_b2  = FloatSlider(description='$b_2$', value=0.0, **slider_param)\n    if plot_param['algo'] is not None:\n        slider_x0  = FloatSlider(description='$x_0$', value=1.0, **slider_param)\n        slider_y0  = FloatSlider(description='$y_0$', value=1.0, **slider_param)\n        slider_stepsize = FloatSlider(description='stepsize', value=0.1, min=0.01, max=1, step=0.05)\n    \n    # we initialize everything\n    A_slider = np.array([[slider_a11.value, slider_a12.value], [slider_a21.value, slider_a22.value]])\n    b_slider = np.array([slider_b1.value, slider_b2.value])\n    plot_param[\"title\"] = print_info(A_slider)\n    if plot_param['algo'] is not None:\n        x0_slider = np.array([slider_x0.value, slider_y0.value])\n        plot_param['x0']= np.array([slider_x0.value, slider_y0.value])\n        stepsize_slider = slider_stepsize.value\n        plot_param['stepsize'] = slider_stepsize.value\n        #plot_param['sequence'] = sequence_gradient(A_slider, b_slider, x0_slider, stepsize_slider, **plot_param)\n\n    # open the figure\n    plt.ioff() # turn off interactive mode to be able to display widget. I honestly don't understand why. see https://github.com/matplotlib/ipympl/issues/220 or https://github.com/matplotlib/matplotlib/pull/17371\n    fig = plt.figure(dpi=dpi)\n    plt.ion()\n    fig.subplots_adjust(left=0.1, right=0.9, bottom=0.1, top=0.9)\n    _, number_plots = get_plots_we_want(**plot_param)\n    plt.gcf().set_size_inches(plt.figaspect(1/number_plots))\n    # plot a first draw\n    plot2d_function(quadratic(A_slider,b_slider), fig,  **plot_param)\n\n    # the function handling the change of parameters\n    def update_plot(change, slider, idx):\n        # store the camera 3D view, then clears the figure\n        if 'graph' in plot_param.keys() and plot_param['graph']:\n            plot_param['azimuth'] = fig.get_axes()[0].azim # remember there are two subplots\n            plot_param['elevation'] = fig.get_axes()[0].elev\n        fig.clear()\n        # update the parameters\n        A = A_slider\n        b = b_slider\n        if slider == 'A':\n            A[idx] = change.new\n        elif slider == 'b':\n            b[idx] = change.new\n        plot_param[\"title\"] = print_info(A)\n        if plot_param['algo'] is not None:\n            plot_param['x0'] = x0_slider\n            plot_param['stepsize'] = stepsize_slider\n            if slider == 'x0':\n                plot_param['x0'][idx] = change.new\n            elif slider == 'stepsize':\n                plot_param['stepsize'] = change.new\n        # plot\n        plot2d_function(quadratic(A,b), fig, **plot_param)\n        _=fig.canvas.draw()\n        _=fig.canvas.flush_events()\n\n    # keep track of changes\n    slider_a11.observe(lambda change : update_plot(change, 'A', (0,0)), names='value')\n    slider_a21.observe(lambda change : update_plot(change, 'A', (1,0)), names='value')\n    slider_a12.observe(lambda change : update_plot(change, 'A', (0,1)), names='value')\n    slider_a22.observe(lambda change : update_plot(change, 'A', (1,1)), names='value')\n    slider_b1.observe(lambda change : update_plot(change, 'b', (0,)), names='value')\n    slider_b2.observe(lambda change : update_plot(change, 'b', (1,)), names='value')\n    if plot_param['algo'] is not None:\n        slider_x0.observe(lambda change : update_plot(change, 'x0', (0,)), names='value')\n        slider_y0.observe(lambda change : update_plot(change, 'x0', (1,)), names='value')\n        slider_stepsize.observe(lambda change : update_plot(change, 'stepsize', None), names='value')\n\n    # now we display all of this\n    # a grid of sliders for the parameters\n    grid = GridspecLayout(2, 3)\n    grid[0,0] = slider_a11\n    grid[1,0] = slider_a21\n    grid[0,1] = slider_a12\n    grid[1,1] = slider_a22\n    grid[0,2] = slider_b1\n    grid[1,2] = slider_b2\n    header=grid\n    # optional sliders for the sequence\n    if plot_param['algo'] is not None:\n        grid2 = GridspecLayout(1, 3)\n        grid2[0,0] = slider_x0\n        grid2[0,1] = slider_y0\n        grid2[0,2] = slider_stepsize\n        footer=grid2\n    else:\n        footer=None\n    \n    # we gather everything\n    return AppLayout(\n        header=header,\n        left_sidebar=None,\n        center=fig.canvas,\n        right_sidebar=None,\n        footer=footer\n    )\n\n\n\n", "meta": {"hexsha": "64141e0add6381c2dc2028f035e2c98000baac69", "size": 19703, "ext": "py", "lang": "Python", "max_stars_repo_path": "nice_functions.py", "max_stars_repo_name": "Guillaume-Garrigos/teaching_online_notebooks", "max_stars_repo_head_hexsha": "9b1b849810da8447e399d163cf914de0e5a35a1b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "nice_functions.py", "max_issues_repo_name": "Guillaume-Garrigos/teaching_online_notebooks", "max_issues_repo_head_hexsha": "9b1b849810da8447e399d163cf914de0e5a35a1b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "nice_functions.py", "max_forks_repo_name": "Guillaume-Garrigos/teaching_online_notebooks", "max_forks_repo_head_hexsha": "9b1b849810da8447e399d163cf914de0e5a35a1b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.1283095723, "max_line_length": 1155, "alphanum_fraction": 0.6291427701, "include": true, "reason": "import numpy", "num_tokens": 5493, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.12252321572224491, "lm_q1q2_score": 0.061261607861122454}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Simple Motion problems and Reminder on Newton's Laws\n# \n# \n# ## Basic Steps of Scientific Investigations\n# \n# \n# An overarching aim in this course is to give you a deeper\n# understanding of the scientific method. The problems we study will all\n# involve cases where we can apply classical mechanics. In our previous\n# material we already assumed that we had a model for the motion of an\n# object.  Alternatively we could have data from experiment (like Usain\n# Bolt's 100m world record run in 2008).  Or we could have performed\n# ourselves an experiment and we want to understand which forces are at\n# play and whether these forces can be understood in terms of\n# fundamental forces.\n# \n# Our first step consists in identifying the problem. What we sketch\n# here may include a mix of experiment and theoretical simulations, or\n# just experiment or only theory.\n# \n# \n# ### Identifying our System\n# \n# Here we can ask questions like\n# 1. What kind of object is moving\n# \n# 2. What kind of data do we have\n# \n# 3. How do we measure position, velocity, acceleration etc\n# \n# 4. Which initial conditions influence our system\n# \n# 5. Other aspects which allow us to identify the system\n# \n# ### Defining a Model\n# \n# With our eventual data and observations we would now like to develop a\n# model for the system. In the end we want obviously to be able to\n# understand which forces are at play and how they influence our\n# specific system. That is, can we extract some deeper insights about a\n# system?\n# \n# We need then to\n# 1. Find the forces that act on our system\n# \n# 2. Introduce models for the forces\n# \n# 3. Identify the equations which can govern the system (Newton's second law for example)\n# \n# 4. More elements we deem important for defining our model\n# \n# ### Solving the Equations\n# \n# With the model at hand, we can then solve the equations. In classical mechanics we normally end up  with solving sets of coupled ordinary differential equations or partial differential equations.\n# 1. Using Newton's second law we have equations of the type $\\boldsymbol{F}=m\\boldsymbol{a}=md\\boldsymbol{v}/dt$\n# \n# 2. We need to  define the initial conditions (typically the initial velocity and position as functions of time) and/or initial conditions and boundary conditions\n# \n# 3. The solution of the equations give us then the position, the velocity and other time-dependent quantities which may specify the motion of a given object.\n# \n# We are not yet done. With our lovely solvers, we need to start thinking.\n# \n# \n# ### Analyze\n# \n# Now it is time to ask the big questions. What do our results mean? Can we give a simple interpretation in terms of fundamental laws?  What do our results mean? Are they correct?\n# Thus, typical questions we may ask are\n# 1. Are our results for say $\\boldsymbol{r}(t)$ valid?  Do we trust what we did?  Can you validate and verify the correctness of your results?\n# \n# 2. Evaluate the answers and their implications\n# \n# 3. Compare with experimental data if possible. Does our model make sense?\n# \n# 4. and obviously many other questions.\n# \n# The analysis stage feeds back to the first stage. It may happen that\n# the data we had were not good enough, there could be large statistical\n# uncertainties. We may need to collect more data or perhaps we did a\n# sloppy job in identifying the degrees of freedom.\n# \n# All these steps are essential elements in a scientific\n# enquiry. Hopefully, through a mix of numerical simulations, analytical\n# calculations and experiments we may gain a deeper insight about the\n# physics of a specific system.\n# \n# \n# ## Newton's Laws\n# \n# Let us now remind ourselves of Newton's laws, since these are the laws of motion we will study in this course.\n# \n# \n# When analyzing a physical system we normally start with distinguishing between the object we are studying (we will label this in more general terms as our **system**) and how this system interacts with the environment (which often means everything else!)\n# \n# In our investigations we will thus analyze a specific physics problem in terms of the system and the environment.\n# In doing so we need to identify the forces that act on the system and assume that the\n# forces acting on the system must have a source, an identifiable cause in\n# the environment.\n# \n# A force acting on for example a falling object must be related to an interaction with something in the environment.\n# This also means that we do not consider internal forces. The latter are forces between\n# one part of the object and another part. In this course we will mainly focus on external forces.\n# \n# Forces are either contact forces or long-range forces.\n# \n# Contact forces, as evident from the name, are forces that occur at the contact between\n# the system and the environment. Well-known long-range forces are the gravitional force and the electromagnetic force.\n# \n# \n# \n# \n# In order to set up the forces which act on an object, the following steps may be useful\n# 1. Divide the problem into system and environment.\n# \n# 2. Draw a figure of the object and everything in contact with the object.\n# \n# 3. Draw a closed curve around the system.\n# \n# 4. Find contact points—these are the points where contact forces may act.\n# \n# 5. Give names and symbols to all the contact forces.\n# \n# 6. Identify the long-range forces.\n# \n# 7. Make a drawing of the object. Draw the forces as arrows, vectors, starting from where the force is acting. The direction of the vector(s) indicates the (positive) direction of the force. Try to make the length of the arrow indicate the relative magnitude of the forces.\n# \n# 8. Draw in the axes of the coordinate system. It is often convenient to make one axis parallel to the direction of motion. When you choose the direction of the axis you also choose the positive direction for the axis.\n# \n# Newton’s second law of motion: The force $\\boldsymbol{F}$ on an object of inertial mass $m$\n# is related to the acceleration a of the object through\n\n# $$\n# \\boldsymbol{F} = m\\boldsymbol{a},\n# $$\n\n# where $\\boldsymbol{a}$ is the acceleration.\n# \n# Newton’s laws of motion are laws of nature that have been found by experimental\n# investigations and have been shown to hold up to continued experimental investigations.\n# Newton’s laws are valid over a wide range of length- and time-scales. We\n# use Newton’s laws of motion to describe everything from the motion of atoms to the\n# motion of galaxies.\n# \n# The second law is a vector equation with the acceleration having the same\n# direction as the force. The acceleration is proportional to the force via the mass $m$ of the system under study.\n# \n# \n# Newton’s second law introduces a new property of an object, the so-called \n# inertial mass $m$. We determine the inertial mass of an object by measuring the\n# acceleration for a given applied force.\n# \n# \n# \n# ### Then the First Law\n# \n# What happens if the net external force on a body is zero? Applying Newton’s second\n# law, we find:\n\n# $$\n# \\boldsymbol{F} = 0 = m\\boldsymbol{a},\n# $$\n\n# which gives using the definition of the acceleration\n\n# $$\n# \\boldsymbol{a} = \\frac{d\\boldsymbol{v}}{dt}=0.\n# $$\n\n# The acceleration is zero, which means that the velocity of the object is constant. This\n# is often referred to as Newton’s first law. An object in a state of uniform motion tends to remain in\n# that state unless an external force changes its state of motion.\n# Why do we need a separate law for this? Is it not simply a special case of Newton’s\n# second law? Yes, Newton’s first law can be deduced from the second law as we have\n# illustrated. However, the first law is often used for a different purpose: Newton’s\n# First Law tells us about the limit of applicability of Newton’s Second law. Newton’s\n# Second law can only be used in reference systems where the First law is obeyed. But\n# is not the First law always valid? No! The First law is only valid in reference systems\n# that are not accelerated. If you observe the motion of a ball from an accelerating\n# car, the ball will appear to accelerate even if there are no forces acting on it. We call\n# systems that are not accelerating inertial systems, and Newton’s first law is often\n# called the law of inertia. Newton’s first and second laws of motion are only valid in\n# inertial systems. \n# \n# A system is an inertial system if it is not accelerated. It means that the reference system\n# must not be accelerating linearly or rotating. Unfortunately, this means that most\n# systems we know are not really inertial systems. For example, the surface of the\n# Earth is clearly not an inertial system, because the Earth is rotating. The Earth is also\n# not an inertial system, because it ismoving in a curved path around the Sun. However,\n# even if the surface of the Earth is not strictly an inertial system, it may be considered\n# to be approximately an inertial system for many laboratory-size experiments.\n# \n# \n# ### And finally the Third Law\n# \n# If there is a force from object A on object B, there is also a force from object B on object A.\n# This fundamental principle of interactions is called Newton’s third law. We do not\n# know of any force that do not obey this law: All forces appear in pairs. Newton’s\n# third law is usually formulated as: For every action there is an equal and opposite\n# reaction.\n# \n# \n# \n# \n# \n# \n# \n# ## Falling baseball in one dimension\n# \n# We anticipate the mathematical model to come and assume that we have a\n# model for the motion of a falling baseball without air resistance.\n# Our system (the baseball) is at an initial height $y_0$ (which we will\n# specify in the program below) at the initial time $t_0=0$. In our program example here we will plot the position in steps of $\\Delta t$ up to a final time $t_f$. \n# The mathematical formula for the position $y(t)$ as function of time $t$ is\n\n# $$\n# y(t) = y_0-\\frac{1}{2}gt^2,\n# $$\n\n# where $g=9.80665=0.980655\\times 10^1$m/s$^2$ is a constant representing the standard acceleration due to gravity.\n# We have here adopted the conventional standard value. This does not take into account other effects, such as buoyancy or drag.\n# Furthermore, we stop when the ball hits the ground, which takes place at\n\n# $$\n# y(t) = 0= y_0-\\frac{1}{2}gt^2,\n# $$\n\n# which gives us a final time $t_f=\\sqrt{2y_0/g}$. \n# \n# As of now we simply assume that   we know the formula for the falling object. Afterwards, we will derive it.\n# \n# \n# \n# We start with preparing folders for storing our calculations, figures and if needed, specific data files we use as input or output files.\n\n# In[1]:\n\n\nget_ipython().run_line_magic('matplotlib', 'inline')\n\n# Common imports\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport os\n\n# Where to save the figures and data files\nPROJECT_ROOT_DIR = \"Results\"\nFIGURE_ID = \"Results/FigureFiles\"\nDATA_ID = \"DataFiles/\"\n\nif not os.path.exists(PROJECT_ROOT_DIR):\n    os.mkdir(PROJECT_ROOT_DIR)\n\nif not os.path.exists(FIGURE_ID):\n    os.makedirs(FIGURE_ID)\n\nif not os.path.exists(DATA_ID):\n    os.makedirs(DATA_ID)\n\ndef image_path(fig_id):\n    return os.path.join(FIGURE_ID, fig_id)\n\ndef data_path(dat_id):\n    return os.path.join(DATA_ID, dat_id)\n\ndef save_fig(fig_id):\n    plt.savefig(image_path(fig_id) + \".png\", format='png')\n\n#in case we have an input file we wish to read in\n#infile = open(data_path(\"MassEval2016.dat\"),'r')\n\n\n# You could also define a function for making our plots. You\n# can obviously avoid this and simply set up various **matplotlib**\n# commands every time you need them. You may however find it convenient\n# to collect all such commands in one function and simply call this\n# function.\n\n# In[2]:\n\n\nfrom pylab import plt, mpl\nplt.style.use('seaborn')\nmpl.rcParams['font.family'] = 'serif'\n\ndef MakePlot(x,y, styles, labels, axlabels):\n    plt.figure(figsize=(10,6))\n    for i in range(len(x)):\n        plt.plot(x[i], y[i], styles[i], label = labels[i])\n        plt.xlabel(axlabels[0])\n        plt.ylabel(axlabels[1])\n    plt.legend(loc=0)\n\n\n# Thereafter we start setting up the code for the falling object.\n\n# In[3]:\n\n\nget_ipython().run_line_magic('matplotlib', 'inline')\nimport matplotlib.patches as mpatches\n\ng = 9.80655 #m/s^2\ny_0 = 10.0 # initial position in meters\nDeltaT = 0.1  # time step\n# final time when y = 0, t = sqrt(2*10/g)\ntfinal = np.sqrt(2.0*y_0/g)\n#set up arrays \nt = np.arange(0,tfinal,DeltaT)\ny =y_0 -g*.5*t**2\n# Then make a nice printout in table form using Pandas\nimport pandas as pd\nfrom IPython.display import display\ndata = {'t[s]': t,\n        'y[m]': y\n        }\nRawData = pd.DataFrame(data)\ndisplay(RawData)\nplt.style.use('ggplot')\nplt.figure(figsize=(8,8))\nplt.scatter(t, y, color = 'b')\nblue_patch = mpatches.Patch(color = 'b', label = 'Height y as function of  time t')\nplt.legend(handles=[blue_patch])\nplt.xlabel(\"t[s]\")\nplt.ylabel(\"y[m]\")\nsave_fig(\"FallingBaseball\")\nplt.show()\n\n\n# Here we used **pandas** (see below) to systemize the output of the position as function of time.\n# \n# \n# \n# We define now the average velocity as\n\n# $$\n# \\overline{v}(t) = \\frac{y(t+\\Delta t)-y(t)}{\\Delta t}.\n# $$\n\n# In the code we have set the time step $\\Delta t$ to a given value. We could define it in terms of the number of points $n$ as\n\n# $$\n# \\Delta t = \\frac{t_{\\mathrm{final}-}t_{\\mathrm{initial}}}{n+1}.\n# $$\n\n# Since we have discretized the variables, we introduce the counter $i$ and let $y(t)\\rightarrow y(t_i)=y_i$ and $t\\rightarrow t_i$\n# with $i=0,1,\\dots, n$. This gives us the following shorthand notations that we will use for the rest of this course. We define\n\n# $$\n# y_i = y(t_i),\\hspace{0.2cm} i=0,1,2,\\dots,n.\n# $$\n\n# This applies to other variables which depend on say time. Examples are the velocities, accelerations, momenta etc.\n# Furthermore we use the shorthand\n\n# $$\n# y_{i\\pm 1} = y(t_i\\pm \\Delta t),\\hspace{0.12cm} i=0,1,2,\\dots,n.\n# $$\n\n# ### Compact equations\n# \n# We can then rewrite in a more compact form the average velocity as\n\n# $$\n# \\overline{v}_i = \\frac{y_{i+1}-y_{i}}{\\Delta t}.\n# $$\n\n# The velocity is defined as the change in position per unit time.\n# In the limit $\\Delta t \\rightarrow 0$ this defines the instantaneous velocity, which is nothing but the slope of the position at a time $t$.\n# We have thus\n\n# $$\n# v(t) = \\frac{dy}{dt}=\\lim_{\\Delta t \\rightarrow 0}\\frac{y(t+\\Delta t)-y(t)}{\\Delta t}.\n# $$\n\n# Similarly, we can define the average acceleration as the change in velocity per unit time as\n\n# $$\n# \\overline{a}_i = \\frac{v_{i+1}-v_{i}}{\\Delta t},\n# $$\n\n# resulting in the instantaneous acceleration\n\n# $$\n# a(t) = \\frac{dv}{dt}=\\lim_{\\Delta t\\rightarrow 0}\\frac{v(t+\\Delta t)-v(t)}{\\Delta t}.\n# $$\n\n# **A note on notations**: When writing for example the velocity as $v(t)$ we are then referring to the continuous and instantaneous value. A subscript like\n# $v_i$ refers always to the discretized values.\n# \n# \n# We can rewrite the instantaneous acceleration as\n\n# $$\n# a(t) = \\frac{dv}{dt}=\\frac{d}{dt}\\frac{dy}{dt}=\\frac{d^2y}{dt^2}.\n# $$\n\n# This forms the starting point for our definition of forces later. It is a famous second-order differential equation. If the acceleration is constant we can now recover the formula for the falling ball we started with.\n# The acceleration can depend on the position and the velocity. To be more formal we should then write the above differential equation as\n\n# $$\n# \\frac{d^2y}{dt^2}=a(t,y(t),\\frac{dy}{dt}).\n# $$\n\n# With given initial conditions for $y(t_0)$ and $v(t_0)$ we can then\n# integrate the above equation and find the velocities and positions at\n# a given time $t$.\n# \n# If we multiply with mass, we have one of the famous expressions for Newton's second law,\n\n# $$\n# F(y,v,t)=m\\frac{d^2y}{dt^2}=ma(t,y(t),\\frac{dy}{dt}),\n# $$\n\n# where $F$ is the force acting on an object with mass $m$. We see that it also has the right dimension, mass times length divided by time squared.\n# We will come back to this soon.\n# \n# \n# ### Integrating our equations\n# \n# Formally we can then, starting with the acceleration (suppose we have measured it, how could we do that?)\n# compute say the height of a building.  To see this we perform the following integrations from an initial time $t_0$  to a given time $t$\n\n# $$\n# \\int_{t_0}^t dt a(t) = \\int_{t_0}^t dt \\frac{dv}{dt} = v(t)-v(t_0),\n# $$\n\n# or as\n\n# $$\n# v(t)=v(t_0)+\\int_{t_0}^t dt a(t).\n# $$\n\n# When we know the velocity as function of time, we can find the position as function of time starting from the defintion of velocity as the derivative with respect to time, that is we have\n\n# $$\n# \\int_{t_0}^t dt v(t) = \\int_{t_0}^t dt \\frac{dy}{dt} = y(t)-y(t_0),\n# $$\n\n# or as\n\n# $$\n# y(t)=y(t_0)+\\int_{t_0}^t dt v(t).\n# $$\n\n# These equations define what is called the integration method for\n# finding the position and the velocity as functions of time. There is\n# no loss of generality if we extend these equations to more than one\n# spatial dimension.\n# \n# \n# Let us compute the velocity using the constant value for the acceleration given by $-g$. We have\n\n# $$\n# v(t)=v(t_0)+\\int_{t_0}^t dt a(t)=v(t_0)+\\int_{t_0}^t dt (-g).\n# $$\n\n# Using our initial time as $t_0=0$s and setting the initial velocity $v(t_0)=v_0=0$m/s we get when integrating\n\n# $$\n# v(t)=-gt.\n# $$\n\n# The more general case is\n\n# $$\n# v(t)=v_0-g(t-t_0).\n# $$\n\n# We can then integrate the velocity and obtain the final formula for the position as function of time through\n\n# $$\n# y(t)=y(t_0)+\\int_{t_0}^t dt v(t)=y_0+\\int_{t_0}^t dt v(t)=y_0+\\int_{t_0}^t dt (-gt),\n# $$\n\n# With $y_0=10$m and $t_0=0$s, we obtain the equation we started with\n\n# $$\n# y(t)=10-\\frac{1}{2}gt^2.\n# $$\n\n# ### Computing the averages\n# \n# After this mathematical background we are now ready to compute the mean velocity using our data.\n\n# In[4]:\n\n\n# Now we can compute the mean velocity using our data\n# We define first an array Vaverage\nn = np.size(t)\nVaverage = np.zeros(n)\nfor i in range(1,n-1):\n    Vaverage[i] = (y[i+1]-y[i])/DeltaT\n# Now we can compute the mean accelearatio using our data\n# We define first an array Aaverage\nn = np.size(t)\nAaverage = np.zeros(n)\nAaverage[0] = -g\nfor i in range(1,n-1):\n    Aaverage[i] = (Vaverage[i+1]-Vaverage[i])/DeltaT\ndata = {'t[s]': t,\n        'y[m]': y,\n        'v[m/s]': Vaverage,\n        'a[m/s^2]': Aaverage\n        }\nNewData = pd.DataFrame(data)\ndisplay(NewData[0:n-2])\n\n\n# Note that we don't print the last values! \n# \n# \n# \n# \n# ## Including Air Resistance in our model\n# \n# In our discussions till now of the falling baseball, we have ignored\n# air resistance and simply assumed that our system is only influenced\n# by the gravitational force.  We will postpone the derivation of air\n# resistance till later, after our discussion of Newton's laws and\n# forces.\n# \n# For our discussions here it suffices to state that the accelerations is now modified to\n\n# $$\n# \\boldsymbol{a}(t) = -g +D\\boldsymbol{v}(t)\\vert v(t)\\vert,\n# $$\n\n# where $\\vert v(t)\\vert$ is the absolute value of the velocity and $D$ is a constant which pertains to the specific object we are studying.\n# Since we are dealing with motion in one dimension, we can simplify the above to\n\n# $$\n# a(t) = -g +Dv^2(t).\n# $$\n\n# We can rewrite this as a differential equation\n\n# $$\n# a(t) = \\frac{dv}{dt}=\\frac{d^2y}{dt^2}= -g +Dv^2(t).\n# $$\n\n# Using the integral equations discussed above we can integrate twice\n# and obtain first the velocity as function of time and thereafter the\n# position as function of time.\n# \n# For this particular case, we can actually obtain an analytical\n# solution for the velocity and for the position. Here we will first\n# compute the solutions analytically, thereafter we will derive Euler's\n# method for solving these differential equations numerically.\n# \n# \n# \n# For simplicity let us just write $v(t)$ as $v$. We have\n\n# $$\n# \\frac{dv}{dt}= -g +Dv^2(t).\n# $$\n\n# We can solve this using the technique of separation of variables. We\n# isolate on the left all terms that involve $v$ and on the right all\n# terms that involve time. We get then\n\n# $$\n# \\frac{dv}{g -Dv^2(t) }= -dt,\n# $$\n\n# We scale now the equation to the left by introducing a constant\n# $v_T=\\sqrt{g/D}$. This constant has dimension length/time. Can you\n# show this?\n# \n# Next we integrate the left-hand side (lhs) from $v_0=0$ m/s to $v$ and\n# the right-hand side (rhs) from $t_0=0$ to $t$ and obtain\n\n# $$\n# \\int_{0}^v\\frac{dv}{g -Dv^2(t) }= \\frac{v_T}{g}\\mathrm{arctanh}(\\frac{v}{v_T})  =-\\int_0^tdt = -t.\n# $$\n\n# We can reorganize these equations as\n\n# $$\n# v_T\\mathrm{arctanh}(\\frac{v}{v_T})  =-gt,\n# $$\n\n# which gives us $v$ as function of time\n\n# $$\n# v(t)=v_T\\tanh{-(\\frac{gt}{v_T})}.\n# $$\n\n# With the velocity we can then find the height $y(t)$ by integrating yet another time, that is\n\n# $$\n# y(t)=y(t_0)+\\int_{t_0}^t dt v(t)=\\int_{0}^t dt[v_T\\tanh{-(\\frac{gt}{v_T})}].\n# $$\n\n# This integral is a little bit trickier but we can look it up in a table over \n# known integrals and we get\n\n# $$\n# y(t)=y(t_0)-\\frac{v_T^2}{g}\\log{[\\cosh{(\\frac{gt}{v_T})}]}.\n# $$\n\n# Alternatively we could have used the symbolic Python package **Sympy**  (example will be inserted later). \n# \n# In most cases however, we need to revert to numerical solutions. \n# \n# \n# \n# ## Our first attempt at solving differential equations\n# \n# Here we will try the simplest possible approach to solving the second-order differential \n# equation\n\n# $$\n# a(t) =\\frac{d^2y}{dt^2}= -g +Dv^2(t).\n# $$\n\n# We rewrite it as two coupled first-order equations (this is a standard approach)\n\n# $$\n# \\frac{dy}{dt} = v(t),\n# $$\n\n# with initial condition $y(t_0)=y_0$ and\n\n# $$\n# a(t) =\\frac{dv}{dt}= -g +Dv^2(t),\n# $$\n\n# with initial condition $v(t_0)=v_0$.\n# \n# Many of the algorithms for solving differential equations start with simple Taylor equations.\n# If we now Taylor expand $y$ and $v$ around a value $t+\\Delta t$ we have\n\n# $$\n# y(t+\\Delta t) = y(t)+\\Delta t \\frac{dy}{dt}+\\frac{\\Delta t^2}{2!} \\frac{d^2y}{dt^2}+O(\\Delta t^3),\n# $$\n\n# and\n\n# $$\n# v(t+\\Delta t) = v(t)+\\Delta t \\frac{dv}{dt}+\\frac{\\Delta t^2}{2!} \\frac{d^2v}{dt^2}+O(\\Delta t^3).\n# $$\n\n# Using the fact that $dy/dt = v$ and $dv/dt=a$ and keeping only terms up to $\\Delta t$ we have\n\n# $$\n# y(t+\\Delta t) = y(t)+\\Delta t v(t)+O(\\Delta t^2),\n# $$\n\n# and\n\n# $$\n# v(t+\\Delta t) = v(t)+\\Delta t a(t)+O(\\Delta t^2).\n# $$\n\n# ### Discretizing our equations\n# \n# Using our discretized versions of the equations with for example\n# $y_{i}=y(t_i)$ and $y_{i\\pm 1}=y(t_i+\\Delta t)$, we can rewrite the\n# above equations as (and truncating at $\\Delta t$)\n\n# $$\n# y_{i+1} = y_i+\\Delta t v_i,\n# $$\n\n# and\n\n# $$\n# v_{i+1} = v_i+\\Delta t a_i.\n# $$\n\n# These are the famous Euler equations (forward Euler).\n# \n# To solve these equations numerically we start at a time $t_0$ and simply integrate up these equations to a final time $t_f$,\n# The step size $\\Delta t$ is an input  parameter in our code.\n# You can define it directly in the code below as\n\n# In[5]:\n\n\nDeltaT = 0.1\n\n\n# With a given final time **tfinal**  we can then find the number of integration points via the **ceil** function included in the **math** package of Python\n# as\n\n# In[6]:\n\n\n#define final time, assuming that initial time is zero\nfrom math import ceil\ntfinal = 0.5\nn = ceil(tfinal/DeltaT)\nprint(n)\n\n\n# The **ceil** function returns the smallest integer not less than the input in say\n\n# In[7]:\n\n\nx = 21.15\nprint(ceil(x))\n\n\n# which in the case here is 22.\n\n# In[8]:\n\n\nx = 21.75\nprint(ceil(x))\n\n\n# which also yields 22. The  **floor** function in the **math** package\n# is used to return the closest integer value which is less than or equal to the specified expression or value.\n# Compare the previous result to the usage of **floor**\n\n# In[9]:\n\n\nfrom math import floor\nx = 21.75\nprint(floor(x))\n\n\n# Alternatively, we can define ourselves the number of integration(mesh) points. In this case we could have\n\n# In[10]:\n\n\nn = 10\ntinitial = 0.0\ntfinal = 0.5\nDeltaT = (tfinal-tinitial)/(n)\nprint(DeltaT)\n\n\n# Since we will set up one-dimensional arrays that contain the values of\n# various variables like time, position, velocity, acceleration etc, we\n# need to know the value of $n$, the number of data points (or\n# integration or mesh points).  With $n$ we can initialize a given array\n# by setting all elelements to zero, as done here\n\n# In[11]:\n\n\n# define array a\na = np.zeros(n)\nprint(a)\n\n\n# In the code here we implement this simple Eurler scheme choosing a value for $D=0.0245$ m/s.\n\n# In[12]:\n\n\n# Common imports\nimport numpy as np\nimport pandas as pd\nfrom math import *\nimport matplotlib.pyplot as plt\nimport os\n\n# Where to save the figures and data files\nPROJECT_ROOT_DIR = \"Results\"\nFIGURE_ID = \"Results/FigureFiles\"\nDATA_ID = \"DataFiles/\"\n\nif not os.path.exists(PROJECT_ROOT_DIR):\n    os.mkdir(PROJECT_ROOT_DIR)\n\nif not os.path.exists(FIGURE_ID):\n    os.makedirs(FIGURE_ID)\n\nif not os.path.exists(DATA_ID):\n    os.makedirs(DATA_ID)\n\ndef image_path(fig_id):\n    return os.path.join(FIGURE_ID, fig_id)\n\ndef data_path(dat_id):\n    return os.path.join(DATA_ID, dat_id)\n\ndef save_fig(fig_id):\n    plt.savefig(image_path(fig_id) + \".png\", format='png')\n\n\ng = 9.80655 #m/s^2\nD = 0.00245 #m/s\nDeltaT = 0.1\n#set up arrays \ntfinal = 0.5\nn = ceil(tfinal/DeltaT)\n# define scaling constant vT\nvT = sqrt(g/D)\n# set up arrays for t, a, v, and y and we can compare our results with analytical ones\nt = np.zeros(n)\na = np.zeros(n)\nv = np.zeros(n)\ny = np.zeros(n)\nyanalytic = np.zeros(n)\n# Initial conditions\nv[0] = 0.0  #m/s\ny[0] = 10.0 #m\nyanalytic[0] = y[0]\n# Start integrating using Euler's method\nfor i in range(n-1):\n    # expression for acceleration\n    a[i] = -g + D*v[i]*v[i]\n    # update velocity and position\n    y[i+1] = y[i] + DeltaT*v[i]\n    v[i+1] = v[i] + DeltaT*a[i]\n    # update time to next time step and compute analytical answer\n    t[i+1] = t[i] + DeltaT\n    yanalytic[i+1] = y[0]-(vT*vT/g)*log(cosh(g*t[i+1]/vT))\n    if ( y[i+1] < 0.0):\n        break\na[n-1] = -g + D*v[n-1]*v[n-1]\ndata = {'t[s]': t,\n        'y[m]': y-yanalytic,\n        'v[m/s]': v,\n        'a[m/s^2]': a\n        }\nNewData = pd.DataFrame(data)\ndisplay(NewData)\n#finally we plot the data\nfig, axs = plt.subplots(3, 1)\naxs[0].plot(t, y, t, yanalytic)\naxs[0].set_xlim(0, tfinal)\naxs[0].set_ylabel('y and exact')\naxs[1].plot(t, v)\naxs[1].set_ylabel('v[m/s]')\naxs[2].plot(t, a)\naxs[2].set_xlabel('time[s]')\naxs[2].set_ylabel('a[m/s^2]')\nfig.tight_layout()\nsave_fig(\"EulerIntegration\")\nplt.show()\n\n\n# Try different values for $\\Delta t$ and study the difference between the exact solution and the numerical solution.\n# \n# \n# ### Simple extension, the Euler-Cromer method\n# \n# The Euler-Cromer method is a simple variant of the standard Euler\n# method. We use the newly updated velocity $v_{i+1}$ as an input to the\n# new position, that is, instead of\n\n# $$\n# y_{i+1} = y_i+\\Delta t v_i,\n# $$\n\n# and\n\n# $$\n# v_{i+1} = v_i+\\Delta t a_i,\n# $$\n\n# we use now the newly calculate for $v_{i+1}$ as input to $y_{i+1}$, that is \n# we compute first\n\n# $$\n# v_{i+1} = v_i+\\Delta t a_i,\n# $$\n\n# and then\n\n# $$\n# y_{i+1} = y_i+\\Delta t v_{i+1},\n# $$\n\n# Implementing the Euler-Cromer method yields a simple change to the previous code. We only need to change the following line in the loop over time\n# steps\n\n# In[13]:\n\n\nfor i in range(n-1):\n    # more codes in between here\n    v[i+1] = v[i] + DeltaT*a[i]\n    y[i+1] = y[i] + DeltaT*v[i+1]\n    # more code\n\n\n# ## Air Resistance in One Dimension\n# \n# \n# Here we look at both a quadratic in velocity resistance\n# and linear in velocity.  But first we give a qualitative argument\n# about the mathematical expression for the air resistance we used last\n# Friday.\n# \n# \n# Air resistance tends to scale as the square of the velocity. This is\n# in contrast to many problems chosen for textbooks, where it is linear\n# in the velocity. The choice of a linear dependence is motivated by\n# mathematical simplicity (it keeps the differential equation linear)\n# rather than by physics. One can see that the force should be quadratic\n# in velocity by considering the momentum imparted on the air\n# molecules. If an object sweeps through a volume $dV$ of air in time\n# $dt$, the momentum imparted on the air is\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto1\"></div>\n# \n# $$\n# \\begin{equation}\n# dP=\\rho_m dV v,\n# \\label{_auto1} \\tag{1}\n# \\end{equation}\n# $$\n\n# where $v$ is the velocity of the object and $\\rho_m$ is the mass\n# density of the air. If the molecules bounce back as opposed to stop\n# you would double the size of the term. The opposite value of the\n# momentum is imparted onto the object itself. Geometrically, the\n# differential volume is\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto2\"></div>\n# \n# $$\n# \\begin{equation}\n# dV=Avdt,\n# \\label{_auto2} \\tag{2}\n# \\end{equation}\n# $$\n\n# where $A$ is the cross-sectional area and $vdt$ is the distance the\n# object moved in time $dt$.\n# \n# \n# Plugging this into the expression above,\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto3\"></div>\n# \n# $$\n# \\begin{equation}\n# \\frac{dP}{dt}=-\\rho_m A v^2.\n# \\label{_auto3} \\tag{3}\n# \\end{equation}\n# $$\n\n# This is the force felt by the particle, and is opposite to its\n# direction of motion. Now, because air doesn't stop when it hits an\n# object, but flows around the best it can, the actual force is reduced\n# by a dimensionless factor $c_W$, called the drag coefficient.\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto4\"></div>\n# \n# $$\n# \\begin{equation}\n# F_{\\rm drag}=-c_W\\rho_m Av^2,\n# \\label{_auto4} \\tag{4}\n# \\end{equation}\n# $$\n\n# and the acceleration is\n\n# $$\n# \\begin{eqnarray}\n# \\frac{dv}{dt}=-\\frac{c_W\\rho_mA}{m}v^2.\n# \\end{eqnarray}\n# $$\n\n# For a particle with initial velocity $v_0$, one can separate the $dt$\n# to one side of the equation, and move everything with $v$s to the\n# other side. We did this in our discussion of simple motion and will not repeat it here.\n# \n# On more general terms,\n# for many systems, e.g. an automobile, there are multiple sources of\n# resistance. In addition to wind resistance, where the force is\n# proportional to $v^2$, there are dissipative effects of the tires on\n# the pavement, and in the axel and drive train. These other forces can\n# have components that scale proportional to $v$, and components that\n# are independent of $v$. Those independent of $v$, e.g. the usual\n# $f=\\mu_K N$ frictional force you consider in your first Physics courses, only set in\n# once the object is actually moving. As speeds become higher, the $v^2$\n# components begin to dominate relative to the others. For automobiles\n# at freeway speeds, the $v^2$ terms are largely responsible for the\n# loss of efficiency. To travel a distance $L$ at fixed speed $v$, the\n# energy/work required to overcome the dissipative forces are $fL$,\n# which for a force of the form $f=\\alpha v^n$ becomes\n\n# $$\n# \\begin{eqnarray}\n# W=\\int dx~f=\\alpha v^n L.\n# \\end{eqnarray}\n# $$\n\n# For $n=0$ the work is\n# independent of speed, but for the wind resistance, where $n=2$,\n# slowing down is essential if one wishes to reduce fuel consumption. It\n# is also important to consider that engines are designed to be most\n# efficient at a chosen range of power output. Thus, some cars will get\n# better mileage at higher speeds (They perform better at 50 mph than at\n# 5 mph) despite the considerations mentioned above.\n# \n# \n# \n# As an example of Newton's Laws we consider projectile motion (or a\n# falling raindrop or a ball we throw up in the air) with a drag force. Even though air resistance is\n# largely proportional to the square of the velocity, we will consider\n# the drag force to be linear to the velocity, $\\boldsymbol{F}=-m\\gamma\\boldsymbol{v}$,\n# for the purposes of this exercise.\n# \n# Such a dependence can be extracted from experimental data for objects moving at low velocities, see for example Malthe-Sørenssen chapter 5.6.\n# \n# We will here focus on a two-dimensional problem.\n# \n# \n# \n# The acceleration for a projectile moving upwards,\n# $\\boldsymbol{a}=\\boldsymbol{F}/m$, becomes\n\n# $$\n# \\begin{eqnarray}\n# \\frac{dv_x}{dt}=-\\gamma v_x,\\\\\n# \\nonumber\n# \\frac{dv_y}{dt}=-\\gamma v_y-g,\n# \\end{eqnarray}\n# $$\n\n# and $\\gamma$ has dimensions of inverse time. \n# \n# If you on the other hand have a falling raindrop, how do these equations change? See for example Figure 2.1 in Taylor.\n# Let us stay with a ball which is thrown up in the air at $t=0$. \n# \n# ## Ways of solving these equations\n# \n# We will go over two different ways to solve this equation. The first\n# by direct integration, and the second as a differential equation. To\n# do this by direct integration, one simply multiplies both sides of the\n# equations above by $dt$, then divide by the appropriate factors so\n# that the $v$s are all on one side of the equation and the $dt$ is on\n# the other. For the $x$ motion one finds an easily integrable equation,\n\n# $$\n# \\begin{eqnarray}\n# \\frac{dv_x}{v_x}&=&-\\gamma dt,\\\\\n# \\nonumber\n# \\int_{v_{0x}}^{v_{x}}\\frac{dv_x}{v_x}&=&-\\gamma\\int_0^{t}dt,\\\\\n# \\nonumber\n# \\ln\\left(\\frac{v_{x}}{v_{0x}}\\right)&=&-\\gamma t,\\\\\n# \\nonumber\n# v_{x}(t)&=&v_{0x}e^{-\\gamma t}.\n# \\end{eqnarray}\n# $$\n\n# This is very much the result you would have written down\n# by inspection. For the $y$-component of the velocity,\n\n# $$\n# \\begin{eqnarray}\n# \\frac{dv_y}{v_y+g/\\gamma}&=&-\\gamma dt\\\\\n# \\nonumber\n# \\ln\\left(\\frac{v_{y}+g/\\gamma}{v_{0y}-g/\\gamma}\\right)&=&-\\gamma t_f,\\\\\n# \\nonumber\n# v_{fy}&=&-\\frac{g}{\\gamma}+\\left(v_{0y}+\\frac{g}{\\gamma}\\right)e^{-\\gamma t}.\n# \\end{eqnarray}\n# $$\n\n# Whereas $v_x$ starts at some value and decays\n# exponentially to zero, $v_y$ decays exponentially to the terminal\n# velocity, $v_t=-g/\\gamma$.\n# \n# \n# \n# Although this direct integration is simpler than the method we invoke\n# below, the method below will come in useful for some slightly more\n# difficult differential equations in the future. The differential\n# equation for $v_x$ is straight-forward to solve. Because it is first\n# order there is one arbitrary constant, $A$, and by inspection the\n# solution is\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto5\"></div>\n# \n# $$\n# \\begin{equation}\n# v_x=Ae^{-\\gamma t}.\n# \\label{_auto5} \\tag{5}\n# \\end{equation}\n# $$\n\n# The arbitrary constants for equations of motion are usually determined\n# by the initial conditions, or more generally boundary conditions. By\n# inspection $A=v_{0x}$, the initial $x$ component of the velocity.\n# \n# \n# ## Differential Equations, contn\n# The differential equation for $v_y$ is a bit more complicated due to\n# the presence of $g$. Differential equations where all the terms are\n# linearly proportional to a function, in this case $v_y$, or to\n# derivatives of the function, e.g., $v_y$, $dv_y/dt$,\n# $d^2v_y/dt^2\\cdots$, are called linear differential equations. If\n# there are terms proportional to $v^2$, as would happen if the drag\n# force were proportional to the square of the velocity, the\n# differential equation is not longer linear. Because this expression\n# has only one derivative in $v$ it is a first-order linear differential\n# equation. If a term were added proportional to $d^2v/dt^2$ it would be\n# a second-order differential equation.  In this case we have a term\n# completely independent of $v$, the gravitational acceleration $g$, and\n# the usual strategy is to first rewrite the equation with all the\n# linear terms on one side of the equal sign,\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto6\"></div>\n# \n# $$\n# \\begin{equation}\n# \\frac{dv_y}{dt}+\\gamma v_y=-g.\n# \\label{_auto6} \\tag{6}\n# \\end{equation}\n# $$\n\n# Now, the solution to the equation can be broken into two\n# parts. Because this is a first-order differential equation we know\n# that there will be one arbitrary constant. Physically, the arbitrary\n# constant will be determined by setting the initial velocity, though it\n# could be determined by setting the velocity at any given time. Like\n# most differential equations, solutions are not \"solved\". Instead,\n# one guesses at a form, then shows the guess is correct. For these\n# types of equations, one first tries to find a single solution,\n# i.e. one with no arbitrary constants. This is called the {\\it\n# particular} solution, $y_p(t)$, though it should really be called\n# \"a\" particular solution because there are an infinite number of such\n# solutions. One then finds a solution to the {\\it homogenous} equation,\n# which is the equation with zero on the right-hand side,\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto7\"></div>\n# \n# $$\n# \\begin{equation}\n# \\frac{dv_{y,h}}{dt}+\\gamma v_{y,h}=0.\n# \\label{_auto7} \\tag{7}\n# \\end{equation}\n# $$\n\n# Homogenous solutions will have arbitrary constants. \n# \n# The particular solution will solve the same equation as the original\n# general equation\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto8\"></div>\n# \n# $$\n# \\begin{equation}\n# \\frac{dv_{y,p}}{dt}+\\gamma v_{y,p}=-g.\n# \\label{_auto8} \\tag{8}\n# \\end{equation}\n# $$\n\n# However, we don't need find one with arbitrary constants. Hence, it is\n# called a **particular** solution.\n# \n# The sum of the two,\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto9\"></div>\n# \n# $$\n# \\begin{equation}\n# v_y=v_{y,p}+v_{y,h},\n# \\label{_auto9} \\tag{9}\n# \\end{equation}\n# $$\n\n# is a solution of the total equation because of the linear nature of\n# the differential equation. One has now found a *general* solution\n# encompassing all solutions, because it both satisfies the general\n# equation (like the particular solution), and has an arbitrary constant\n# that can be adjusted to fit any initial condition (like the homogeneous\n# solution). If the equations were not linear, that is if there were terms\n# such as $v_y^2$ or $v_y\\dot{v}_y$, this technique would not work.\n# \n# \n# \n# Returning to the example above, the homogenous solution is the same as\n# that for $v_x$, because there was no gravitational acceleration in\n# that case,\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto10\"></div>\n# \n# $$\n# \\begin{equation}\n# v_{y,h}=Be^{-\\gamma t}.\n# \\label{_auto10} \\tag{10}\n# \\end{equation}\n# $$\n\n# In this case a particular solution is one with constant velocity,\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto11\"></div>\n# \n# $$\n# \\begin{equation}\n# v_{y,p}=-g/\\gamma.\n# \\label{_auto11} \\tag{11}\n# \\end{equation}\n# $$\n\n# Note that this is the terminal velocity of a particle falling from a\n# great height. The general solution is thus,\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto12\"></div>\n# \n# $$\n# \\begin{equation}\n# v_y=Be^{-\\gamma t}-g/\\gamma,\n# \\label{_auto12} \\tag{12}\n# \\end{equation}\n# $$\n\n# and one can find $B$ from the initial velocity,\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto13\"></div>\n# \n# $$\n# \\begin{equation}\n# v_{0y}=B-g/\\gamma,~~~B=v_{0y}+g/\\gamma.\n# \\label{_auto13} \\tag{13}\n# \\end{equation}\n# $$\n\n# Plugging in the expression for $B$ gives the $y$ motion given the initial velocity,\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto14\"></div>\n# \n# $$\n# \\begin{equation}\n# v_y=(v_{0y}+g/\\gamma)e^{-\\gamma t}-g/\\gamma.\n# \\label{_auto14} \\tag{14}\n# \\end{equation}\n# $$\n\n# It is easy to see that this solution has $v_y=v_{0y}$ when $t=0$ and\n# $v_y=-g/\\gamma$ when $t\\rightarrow\\infty$.\n# \n# One can also integrate the two equations to find the coordinates $x$\n# and $y$ as functions of $t$,\n\n# $$\n# \\begin{eqnarray}\n# x&=&\\int_0^t dt'~v_{0x}(t')=\\frac{v_{0x}}{\\gamma}\\left(1-e^{-\\gamma t}\\right),\\\\\n# \\nonumber\n# y&=&\\int_0^t dt'~v_{0y}(t')=-\\frac{gt}{\\gamma}+\\frac{v_{0y}+g/\\gamma}{\\gamma}\\left(1-e^{-\\gamma t}\\right).\n# \\end{eqnarray}\n# $$\n\n# If the question was to find the position at a time $t$, we would be\n# finished. However, the more common goal in a projectile equation\n# problem is to find the range, i.e. the distance $x$ at which $y$\n# returns to zero. For the case without a drag force this was much\n# simpler. The solution for the $y$ coordinate would have been\n# $y=v_{0y}t-gt^2/2$. One would solve for $t$ to make $y=0$, which would\n# be $t=2v_{0y}/g$, then plug that value for $t$ into $x=v_{0x}t$ to\n# find $x=2v_{0x}v_{0y}/g=v_0\\sin(2\\theta_0)/g$. One follows the same\n# steps here, except that the expression for $y(t)$ is more\n# complicated. Searching for the time where $y=0$, and we get\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto15\"></div>\n# \n# $$\n# \\begin{equation}\n# 0=-\\frac{gt}{\\gamma}+\\frac{v_{0y}+g/\\gamma}{\\gamma}\\left(1-e^{-\\gamma t}\\right).\n# \\label{_auto15} \\tag{15}\n# \\end{equation}\n# $$\n\n# This cannot be inverted into a simple expression $t=\\cdots$. Such\n# expressions are known as \"transcendental equations\", and are not the\n# rare instance, but are the norm. In the days before computers, one\n# might plot the right-hand side of the above graphically as\n# a function of time, then find the point where it crosses zero.\n# \n# Now, the most common way to solve for an equation of the above type\n# would be to apply Newton's method numerically. This involves the\n# following algorithm for finding solutions of some equation $F(t)=0$.\n# \n# 1. First guess a value for the time, $t_{\\rm guess}$.\n# \n# 2. Calculate $F$ and its derivative, $F(t_{\\rm guess})$ and $F'(t_{\\rm guess})$. \n# \n# 3. Unless you guessed perfectly, $F\\ne 0$, and assuming that $\\Delta F\\approx F'\\Delta t$, one would choose \n# \n# 4. $\\Delta t=-F(t_{\\rm guess})/F'(t_{\\rm guess})$.\n# \n# 5. Now repeat step 1, but with $t_{\\rm guess}\\rightarrow t_{\\rm guess}+\\Delta t$.\n# \n# If the $F(t)$ were perfectly linear in $t$, one would find $t$ in one\n# step. Instead, one typically finds a value of $t$ that is closer to\n# the final answer than $t_{\\rm guess}$. One breaks the loop once one\n# finds $F$ within some acceptable tolerance of zero. A program to do\n# this will be added shortly.\n# \n# ## Motion in a Magnetic Field\n# \n# \n# Another example of a velocity-dependent force is magnetism,\n\n# $$\n# \\begin{eqnarray}\n# \\boldsymbol{F}&=&q\\boldsymbol{v}\\times\\boldsymbol{B},\\\\\n# \\nonumber\n# F_i&=&q\\sum_{jk}\\epsilon_{ijk}v_jB_k.\n# \\end{eqnarray}\n# $$\n\n# For a uniform field in the $z$ direction $\\boldsymbol{B}=B\\hat{z}$, the force can only have $x$ and $y$ components,\n\n# $$\n# \\begin{eqnarray}\n# F_x&=&qBv_y\\\\\n# \\nonumber\n# F_y&=&-qBv_x.\n# \\end{eqnarray}\n# $$\n\n# The differential equations are\n\n# $$\n# \\begin{eqnarray}\n# \\dot{v}_x&=&\\omega_c v_y,\\omega_c= qB/m\\\\\n# \\nonumber\n# \\dot{v}_y&=&-\\omega_c v_x.\n# \\end{eqnarray}\n# $$\n\n# One can solve the equations by taking time derivatives of either equation, then substituting into the other equation,\n\n# $$\n# \\begin{eqnarray}\n# \\ddot{v}_x=\\omega_c\\dot{v_y}=-\\omega_c^2v_x,\\\\\n# \\nonumber\n# \\ddot{v}_y&=&-\\omega_c\\dot{v}_x=-\\omega_cv_y.\n# \\end{eqnarray}\n# $$\n\n# The solution to these equations can be seen by inspection,\n\n# $$\n# \\begin{eqnarray}\n# v_x&=&A\\sin(\\omega_ct+\\phi),\\\\\n# \\nonumber\n# v_y&=&A\\cos(\\omega_ct+\\phi).\n# \\end{eqnarray}\n# $$\n\n# One can integrate the equations to find the positions as a function of time,\n\n# $$\n# \\begin{eqnarray}\n# x-x_0&=&\\int_{x_0}^x dx=\\int_0^t dt v(t)\\\\\n# \\nonumber\n# &=&\\frac{-A}{\\omega_c}\\cos(\\omega_ct+\\phi),\\\\\n# \\nonumber\n# y-y_0&=&\\frac{A}{\\omega_c}\\sin(\\omega_ct+\\phi).\n# \\end{eqnarray}\n# $$\n\n# The trajectory is a circle centered at $x_0,y_0$ with amplitude $A$ rotating in the clockwise direction.\n# \n# The equations of motion for the $z$ motion are\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto16\"></div>\n# \n# $$\n# \\begin{equation}\n# \\dot{v_z}=0,\n# \\label{_auto16} \\tag{16}\n# \\end{equation}\n# $$\n\n# which leads to\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto17\"></div>\n# \n# $$\n# \\begin{equation}\n# z-z_0=V_zt.\n# \\label{_auto17} \\tag{17}\n# \\end{equation}\n# $$\n\n# Added onto the circle, the motion is helical.\n# \n# Note that the kinetic energy,\n\n# <!-- Equation labels as ordinary links -->\n# <div id=\"_auto18\"></div>\n# \n# $$\n# \\begin{equation}\n# T=\\frac{1}{2}m(v_x^2+v_y^2+v_z^2)=\\frac{1}{2}m(\\omega_c^2A^2+V_z^2),\n# \\label{_auto18} \\tag{18}\n# \\end{equation}\n# $$\n\n# is constant. This is because the force is perpendicular to the\n# velocity, so that in any differential time element $dt$ the work done\n# on the particle $\\boldsymbol{F}\\cdot{dr}=dt\\boldsymbol{F}\\cdot{v}=0$.\n# \n# One should think about the implications of a velocity dependent\n# force. Suppose one had a constant magnetic field in deep space. If a\n# particle came through with velocity $v_0$, it would undergo cyclotron\n# motion with radius $R=v_0/\\omega_c$. However, if it were still its\n# motion would remain fixed. Now, suppose an observer looked at the\n# particle in one reference frame where the particle was moving, then\n# changed their velocity so that the particle's velocity appeared to be\n# zero. The motion would change from circular to fixed. Is this\n# possible?\n# \n# The solution to the puzzle above relies on understanding\n# relativity. Imagine that the first observer believes $\\boldsymbol{B}\\ne 0$ and\n# that the electric field $\\boldsymbol{E}=0$. If the observer then changes\n# reference frames by accelerating to a velocity $\\boldsymbol{v}$, in the new\n# frame $\\boldsymbol{B}$ and $\\boldsymbol{E}$ both change. If the observer moved to the\n# frame where the charge, originally moving with a small velocity $v$,\n# is now at rest, the new electric field is indeed $\\boldsymbol{v}\\times\\boldsymbol{B}$,\n# which then leads to the same acceleration as one had before. If the\n# velocity is not small compared to the speed of light, additional\n# $\\gamma$ factors come into play,\n# $\\gamma=1/\\sqrt{1-(v/c)^2}$. Relativistic motion will not be\n# considered in this course.\n# \n# \n# \n# ## Summarizing the various motion problems\n# \n# The examples we have discussed above were included in order to\n# illustrate various methods (which depend on the specific problem) to\n# find the solutions of the equations of motion.\n# We have solved the equations of motion in the following ways:\n# \n# **Solve the differential equations analytically.**\n# \n# We did this for example with the following object in one or two dimensions or the sliding block. \n# Here we had for example an equation set like\n\n# $$\n# \\frac{dv_x}{dt}=-\\gamma v_x,\n# $$\n\n# and\n\n# $$\n# \\frac{dv_y}{dt}=-\\gamma v_y-g,\n# $$\n\n# and $\\gamma$ has dimension of inverse time.\n# \n# \n# \n# \n# \n# We could also in case we can separate the degrees of freedom integrate. Take for example one of the equations in the previous slide\n\n# $$\n# \\frac{dv_x}{dt}=-\\gamma v_x,\n# $$\n\n# which we can rewrite in terms of a left-hand side which depends only on the velocity and a right-hand side which depends only on time\n\n# $$\n# \\frac{dv_x}{v_x}=-\\gamma dt.\n# $$\n\n# Integrating we have (since we can separate $v_x$ and $t$)\n\n# $$\n# \\int_{v_0}^{v_t}\\frac{dv_x}{v_x}=-\\int_{t_0}^{t_f}\\gamma dt,\n# $$\n\n# where $v_f$ is the velocity at a final time and $t_f$ is the final time.\n# In this case we found, after having integrated the above two sides that\n\n# $$\n# v_f(t)=v_0\\exp{-\\gamma t}.\n# $$\n\n# Finally, using for example Euler's method, we can solve the\n# differential equations numerically. If we can compare our numerical\n# solutions with analytical solutions, we have an extra check of our\n# numerical approaches.\n# \n# ## Exercises\n# \n# \n# ### Electron moving into an electric field\n# \n# An electron is sent through a varying electrical\n# field. Initially, the electron is moving in the $x$-direction with a velocity\n# $v_x = 100$ m/s. The electron enters the field when it passes the origin. The field\n# varies with time, causing an acceleration of the electron that varies in time\n\n# $$\n# \\boldsymbol{a}(t)=\\left(−20 \\mathrm{m/s}^2 −10\\mathrm{m/s}^3t\\right) \\boldsymbol{e}_y,\n# $$\n\n# or if we replace $\\boldsymbol{e}_y$ with $\\boldsymbol{e}_2$ (the unit vectors in the $y$-direction) we have\n\n# $$\n# \\boldsymbol{a}(t)=\\left(−20 \\mathrm{m/s}^2 −10\\mathrm{m/s}^3t\\right) \\boldsymbol{e}_2.\n# $$\n\n# Note that the velocity in the $x$-direction is a constant and is not affected by the force which acts only in the $y$-direction.\n# This means that we can decouple the two degrees of freedom and skip the vector symbols.\n# We have then a constant velocity in the $x$-direction\n\n# $$\n# v_x(t) = 100\\mathrm{m/s},\n# $$\n\n# and integrating up the acceleration in the $y$-direction (and using that the initial time $t_0=0$) we get\n\n# $$\n# v_y(t) = -20\\mathrm{m/s^2}t-5\\mathrm{m/s^3}t^2.\n# $$\n\n# Find the position as a function of time for the electron.\n# \n# \n# We integrate again in the $x$-direction\n\n# $$\n# x(t) = 100\\mathrm{m/s}t,\n# $$\n\n# and in the $y$-direction (remember that these two degrees of freedom don't depend on each other)\n# we get\n\n# $$\n# y(t) = -10\\mathrm{m/s^2}t^2-\\frac{5}{3}\\mathrm{m/s^3}t^3.\n# $$\n\n# The field is only acting inside a box of length $L = 2m$.\n# \n# How long time is the electron inside the field?\n# \n# \n# If we use the equation for the $x$-direction (the length of the box), we can then use the equation for $x(t) = 100\\mathrm{m/s}t$\n# and simply set $x=2$m and we find\n\n# $$\n# t=\\frac{1}{50}\\mathrm{s}.\n# $$\n\n# What is the displacement in the $y$-direction when the electron leaves the box. (We call this the deflection of the electron).\n# \n# \n# Here we simply use\n\n# $$\n# y(t) = -10\\mathrm{m/s^2}t^2-\\frac{5}{3}\\mathrm{m/s^3}t^3,\n# $$\n\n# and use $t=1/50$s and find that\n\n# $$\n# y = -0.004013 \\mathrm{m}.\n# $$\n\n# Find the angle the velocity vector forms with the horizontal axis as the electron leaves the box.\n# \n# \n# Again, we use $t=1/50$s and calculate the velocities in the $x$- and the $y$-directions (the velocity in the $x$-direction is just a constant) and find the angle using\n\n# $$\n# \\tan{\\alpha} = \\frac{v_y(t=1/50)}{v_x(t=1/50)},\n# $$\n\n# which leads to\n\n# $$\n# \\alpha = -0.23,\n# $$\n\n# in degrees (not radians).\n# \n# ### Drag force\n# \n# Using equations (2.84) and (2.82) in Taylor, we have that $f_{\\mathrm{quad}}/f_{\\mathrm{lin}}=(\\kappa\\rho Av^2)/(3\\pi\\eta Dv)$. With $\\kappa =1/4$ and $A=\\pi D^2/4$ we obtain $f_{\\mathrm{quad}}/f_{\\mathrm{lin}}=(\\rho Dv)/(48\\eta)$ or $R/48$ with $R$ given by equation (2.83) of Taylor.\n# \n# With these numbers $R=1.1\\times 10^{-2}$ and it is safe to neglect the quadratic drag.\n# \n# ### Falling object\n# \n# If we insert Taylor series for $\\exp{-(t/\\tau)}$ into equation (2.33) of Taylor, we have\n\n# $$\n# v_y(t) = v_{\\mathrm{ter}}\\left[1-\\exp{-(t/\\tau)}\\right] = v_{\\mathrm{ter}}\\left[1-(1-\\frac{t}{\\tau}+\\frac{t^2}{2\\tau^2}+\\dots   )\\right].\n# $$\n\n# The first two terms on the right cancel and, if $t$ is sufficiently small, we can neglect terms with higher powers than two in $t$.  This gives us\n\n# $$\n# v_y(t) \\approx v_{\\mathrm{ter}}\\frac{t}{\\tau}=gt,\n# $$\n\n# where we used that $v_{\\mathrm{ter}}=g\\tau$ from equation (2.34) in Taylor. This means that for small velocities it is the gravitational force which dominates.\n# \n# Setting $v_y(t_0)=0$ in equation (2.35) of Taylor and using the Taylor series for the exponential we find that\n\n# $$\n# y(t) = v_{\\mathrm{ter}}t-v_{\\mathrm{ter}}\\tau\\left[1-\\exp{-(t/\\tau)}\\right] = v_{\\mathrm{ter}}t-v_{\\mathrm{ter}}\\tau\\left[1-(1-\\frac{t}{\\tau}+\\frac{t^2}{2\\tau^2}+\\dots   )\\right].\n# $$\n\n# On the rhs the second and third terms cancel, as do the first and fourth. If we neglect all terms beyond $t^2$, this leaves us with\n\n# $$\n# y(t) \\approx v_{\\mathrm{ter}}\\frac{t^2}{2\\tau}=\\frac{1}{2}gt^2.\n# $$\n\n# Again, for small times, as expected, the gravitational force plays the major role.\n# \n# ### Motion of a cyclist\n# \n# Putting in the numbers for the characteristic time we find\n\n# $$\n# \\tau = \\frac{m}{Dv_0} = \\frac{80}{0.20\\times 20}=20\\mathrm{s}.\n# $$\n\n# From an initial velocity of 20m/s we will slow down to half the initial speed, 10m/s in 20s.  From Taylor equation (2.45) we have then that the time to slow down to any speed $v$ is\n\n# $$\n# t = \\frac{M}{D}\\left(\\frac{1}{v}-\\frac{1}{v_0}\\right).\n# $$\n\n# This gives a time of 6.7s for a velocity of 15m/s, 20s for a velocity of 10m/s and 60s for a velocity of 5m/s.  We see that this approximation leads to an infinite time before we come to rest. To ignore ordinary friction at low speeds is indeed a bad approximation.\n# \n# \n# \n# ### Falling ball and preparing for the numerical exercise\n# \n# In this example we study the motion of an object subject to a constant force, a velocity dependent\n# force, and for the numerical part a position-dependent force.\n# Without the position dependent force, we can solve the problem analytically. This is what we will do in this exercise.\n# The position dependent force requires numerical efforts (exercise 7).\n# In addition to the  falling ball case, we will include the effect of the ball bouncing back from the floor in exercises 7.\n# \n# \n# Here we limit ourselves to a ball that is thrown from a height $h$\n# above the ground with an initial velocity\n# $\\boldsymbol{v}_0$ at time $t=t_0$.\n# We assume we have only a gravitational force and a force due to the air resistance.\n# The position of the ball as function of time is  $\\boldsymbol{r}(t)$ where $t$ is time.\n#  The position is measured with respect to a coordinate system with origin at the floor.\n# \n# We assume we have an initial position $\\boldsymbol{r}(t_0)=h\\boldsymbol{e}_y$ and an initial velocity $\\boldsymbol{v}_0=v_{x,0}\\boldsymbol{e}_x+v_{y,0}\\boldsymbol{e}_y$.\n# \n# In this exercise we assume the system is influenced by the gravitational force\n\n# $$\n# \\boldsymbol{G}=-mg\\boldsymbol{e}_y\n# $$\n\n# and an air resistance given by a square law\n\n# $$\n# -Dv\\boldsymbol{v}.\n# $$\n\n# The analytical expressions for velocity and position as functions of\n# time will be used to compare with the numerical results in exercise 6.\n# \n# Identify the forces acting on the ball and set up a diagram with the forces acting on the ball. Find the acceleration of the falling ball.\n# \n# The forces acting on the ball are the gravitational force $\\boldsymbol{G}=-mg\\boldsymbol{e}_y$ and the air resistance $\\boldsymbol{F}_D=-D\\boldsymbol{v}v$ with $v$ the absolute value of the velocity. The accelaration in the $x$-direction is\n\n# $$\n# a_x = -\\frac{Dv_x\\vert v\\vert}{m},\n# $$\n\n# and in the $y$-direction\n\n# $$\n# a_y = -g-\\frac{Dv_y\\vert v\\vert}{m},\n# $$\n\n# where $\\vert v\\vert=\\sqrt{v_x^2+v_y^2}$.  Note that due to the dependence on $v_x$ and $v_y$ in each equation, it means we may not be able find an analytical solution. In this case we cannot.\n# In order to compare our code with analytical results, we will thus study the problem only in the $y$-direction.\n# \n# In the general code below we would write this as (pseudocode style)\n\n# In[14]:\n\n\nax = -D*vx[i]*abs(v[i])/m\nay = -g - D*vy[i]*abs(v[i])/m\n\n\n# Integrate the acceleration from an initial time $t_0$ to a final time $t$ and find the velocity.\n# \n# We reduce our problem to a one-dimensional in the $y$-direction only since for the two-dimensional motion we cannot find an analtical solution. For one dimension however, we have an analytical solution.\n# We specialize our equations  for the $y$-direction only\n\n# $$\n# \\frac{dv_y}{dt}= -g +Dv_y^2(t).\n# $$\n\n# We can solve this using the technique of separation of variables. We\n# isolate on the left all terms that involve $v$ and on the right all\n# terms that involve time. We get then\n\n# $$\n# \\frac{dv_y}{g -Dv_y^2(t) }= -dt,\n# $$\n\n# We scale now the equation to the left by introducing a constant\n# $v_T=\\sqrt{g/D}$. This constant has dimension length/time. \n# \n# Next we integrate the left-hand side (lhs) from $v_{y0}=0$ m/s to $v$ and\n# the right-hand side (rhs) from $t_0=0$ to $t$ and obtain\n\n# $$\n# \\int_{0}^{v_y}\\frac{dv_y}{g -Dv_y^2(t) }= \\frac{v_T}{g}\\mathrm{arctanh}(\\frac{v_y}{v_T})  =-\\int_0^tdt = -t.\n# $$\n\n# We can reorganize these equations as\n\n# $$\n# v_T\\mathrm{arctanh}(\\frac{v_y}{v_T})  =-gt,\n# $$\n\n# which gives us $v_y$ as function of time\n\n# $$\n# v_y(t)=v_T\\tanh{-(\\frac{gt}{v_T})}.\n# $$\n\n# With a finite initial velocity we need simply to add $v_{y0}$.\n# \n# \n# \n# Find thereafter the position as function of time starting with an initial time $t_0$. Find the time it takes to hit the floor.  Here you will find it convenient to set the initial velocity in the $y$-direction to zero.\n# \n# \n# With the velocity we can then find the height $y(t)$ by integrating yet another time, that is\n\n# $$\n# y(t)=y(t_0)+\\int_{t_0}^t dt v_y(t)=\\int_{0}^t dt[v_T\\tanh{-(\\frac{gt}{v_T})}].\n# $$\n\n# This integral is a little bit trickier but we can look it up in a table over \n# known integrals and we get\n\n# $$\n# y(t)=y(t_0)-\\frac{v_T^2}{g}\\log{[\\cosh{(\\frac{gt}{v_T})}]}.\n# $$\n\n# Here we have assumed that we set the initial velocity in the $y$-direction to zero, that is $v_y(t_0)=0$m/s. Adding a non-zero velocity gives us an additional term of $v_{y0}t$.  \n# Using a zero initial velocity and setting\n\n# $$\n# y(t)=0=y(t_0)-\\frac{v_T^2}{g}\\log{[\\cosh{(-\\frac{gt}{v_T})}]}=y(t_0)-\\frac{v_T^2}{g}\\log{[\\cosh{(\\frac{gt}{v_T})}]},\n# $$\n\n# (note that $\\cosh$ yields the same values for negative and positive arguments)\n# allows us to find the final time by solving\n\n# $$\n# y(t_0)=\\frac{v_T^2}{g}\\log{[\\cosh{(\\frac{gt}{v_T})}]},\n# $$\n\n# which gives\n\n# $$\n# t = \\frac{v_T}{g}\\mathrm{arccosh}(\\exp{(gy_0/v_T^2)}).\n# $$\n\n# In the code below we would code these analytical expressions (with zero initial velocity in the $y$-direction) as\n\n# In[ ]:\n\n\nyanalytic[i+1] = y[0]-(vT*vT/g)*log(cosh(g*t[i+1]/vT))+vy[0]*t[i+1]\n\n\n# We will use the above analytical results in our numerical calculations in the next exercise\n# \n# \n# \n# \n# ### Numerical elements, solving the previous exercise  numerically and adding the bouncing from the floor\n# \n# Here we will:\n# 1. Learn and utilize Euler's Method to find the position and the velocity\n# \n# 2. Compare analytical and computational solutions \n# \n# 3. Add additional forces to our model\n\n# In[ ]:\n\n\n# let's start by importing useful packages we are familiar with\nimport numpy as np\nimport matplotlib.pyplot as plt\nget_ipython().run_line_magic('matplotlib', 'inline')\n\n\n# We will choose the following values\n# 1. mass $m=0,2$ kg\n# \n# 2. accelleration (gravity) $g=9.81$ m/s$^{2}$.\n# \n# 3. initial position is the height $h=2$ m\n# \n# 4. initial velocities $v_{x,0}=v_{y,0}=10$ m/s\n# \n# Can you find a reasonable value for the drag coefficient $D$?\n# You need also to define an initial time and \n# the step size $\\Delta t$. We can define the step size $\\Delta t$ as the difference between any\n# two neighboring values in time (time steps) that we analyze within\n# some range. It can be determined by dividing the interval we are\n# analyzing, which in our case is time $t_{\\mathrm{final}}-t_0$, by the number of steps we\n# are taking $(N)$. This gives us a step size $\\Delta t = \\dfrac{t_{\\mathrm{final}}-t_0}{N}$.\n# \n# With these preliminaries we are now ready to plot our results from exercise 5.\n# \n# Set up arrays for time, velocity, acceleration and positions for the results from exercise 5. Define an initial and final time. Choose the final time to be the time when the ball hits the ground for the first time. Make a plot of the position and velocity as functions of time.  Here you could set the initial velocity in the $y$-direction to zero and use the result from exercise 5. Else you need to try different initial times using the result from exercise 5 as a starting guess.  It is not critical if you don't reach the ground when the initial velocity in the $y$-direction is not zero.\n# \n# \n# We move now to the numerical solution of the differential equations as discussed in the [lecture notes](https://mhjensen.github.io/Physics321/doc/pub/motion/html/motion.html) or Malthe-Sørenssen chapter 7.5.\n# Let us remind ourselves about  Euler's Method.\n# \n# Suppose we know $f(t)$ and its derivative $f'(t)$. To find $f(t+\\Delta t)$ at the next step, $t+\\Delta t$,\n# we can consider the Taylor expansion:\n# \n# $f(t+\\Delta t) = f(t) + \\dfrac{(\\Delta t)f'(t)}{1!} + \\dfrac{(\\Delta t)^2f''(t)}{2!} + ...$\n# \n# If we ignore the $f''$ term and higher derivatives, we obtain\n# \n# $f(t+\\Delta t) \\approx f(t) + (\\Delta t)f'(t)$.\n# \n# This approximation is the basis of Euler's method, and the Taylor\n# expansion suggests that it will have errors of $O(\\Delta t^2)$.  Thus, one\n# would expect it to work better, the smaller the step size $h$ that you\n# use. In our case the step size is $\\Delta t$. \n# \n# In setting up our code we need to\n# \n# 1. Define and obtain all initial values, constants, and time to be analyzed with step sizes as done above (you can use the same values)\n# \n# 2. Calculate the velocity using $v_{i+1} = v_{i} + (\\Delta t)*a_{i}$\n# \n# 3. Calculate the position using $pos_{i+1} = r_{i} + (\\Delta t)*v_{i}$\n# \n# 4. Calculate the new acceleration $a_{i+1}$.\n# \n# 5. Repeat steps 2-4 for all time steps within a loop.\n# \n# Write a code which implements Euler's method and compute numerically and plot the position and velocity as functions of time for various values of $\\Delta t$. Comment your results.\n# \n# Below you will find two codes, one which uses explicit expressions for the $x$- and $y$-directions and one which rewrites the expressions as compact vectors, as done in homework 2. Running the codes shows a sensitivity to the chosen step size $\\Delta t$. You will clearly notice that when comparing with the analytical results, that larger values of the step size in time result in a poorer agreement with the analytical solutions.\n# \n# * Compare your numerically obtained positions and velocities with the analytical results from exercise 5. Comment again your results.\n# \n# The codes follow here. Running them allows you to probe the various parameters and compare with analytical solutions as well. \n# \n# The analytical results are discussed in the lecture notes, see the slides of the week of January 25-29 <https://mhjensen.github.io/Physics321/doc/pub/week4/html/week4-bs.html>.\n# \n# \n# The codes here show two different ways of solving the two-dimensional problem. The first one defines arrays for the $x$- and $y$-directions explicitely, while the second code uses a more\n# compact (and thus closer to the mathmeatics) notation with a full two-dimensional vector.\n# \n# \n# The initial conditions for the first example are set so that we only an object falling in the $y$-direction. Then it makes sense to compare with the analytical solution. If you change the initial conditions, this comparison is no longer correct.\n\n# In[ ]:\n\n\n# Exercise 6, hw3, brute force way with declaration of vx, vy, x and y\n# Common imports\nimport numpy as np\nimport pandas as pd\nfrom math import *\nimport matplotlib.pyplot as plt\nimport os\n\n# Where to save the figures and data files\nPROJECT_ROOT_DIR = \"Results\"\nFIGURE_ID = \"Results/FigureFiles\"\nDATA_ID = \"DataFiles/\"\n\nif not os.path.exists(PROJECT_ROOT_DIR):\n    os.mkdir(PROJECT_ROOT_DIR)\n\nif not os.path.exists(FIGURE_ID):\n    os.makedirs(FIGURE_ID)\n\nif not os.path.exists(DATA_ID):\n    os.makedirs(DATA_ID)\n\ndef image_path(fig_id):\n    return os.path.join(FIGURE_ID, fig_id)\n\ndef data_path(dat_id):\n    return os.path.join(DATA_ID, dat_id)\n\ndef save_fig(fig_id):\n    plt.savefig(image_path(fig_id) + \".png\", format='png')\n\n# Output file\noutfile = open(data_path(\"Eulerresults.dat\"),'w')\n\nfrom pylab import plt, mpl\nplt.style.use('seaborn')\nmpl.rcParams['font.family'] = 'serif'\n\n\ng = 9.80655 #m/s^2\n# The mass and the drag constant D\nD = 0.00245 #mass/length   kg/m\nm = 0.2 #kg, mass of falling object\nDeltaT = 0.001\n#set up arrays \ntfinal = 1.4\n# set up number of points for all variables\nn = ceil(tfinal/DeltaT)\n# define scaling constant vT used in analytical solution\nvT = sqrt(m*g/D)\n# set up arrays for t, a, v, and y and arrays for analytical results\n#brute force setting up of arrays for x and y, vx, vy, ax and ay\nt = np.zeros(n)\nvy = np.zeros(n)\ny = np.zeros(n)\nvx = np.zeros(n)\nx = np.zeros(n)\nyanalytic = np.zeros(n)\n# Initial conditions, note that these correspond to an object falling in the y-direction only.\nvx[0] = 0.0 #m/s\nvy[0] = 0.0  #m/s\ny[0] = 10.0 #m\nx[0] = 0.0 #m\nyanalytic[0] = y[0]\n# Start integrating using Euler's method\nfor i in range(n-1):\n    # expression for acceleration, note the absolute value and division by mass\n    ax = -D*vx[i]*sqrt(vx[i]**2+vy[i]**2)/m\n    ay = -g - D*vy[i]*sqrt(vx[i]**2+vy[i]**2)/m\n    # update velocity and position\n    vx[i+1] = vx[i] + DeltaT*ax\n    x[i+1] = x[i] + DeltaT*vx[i]\n    vy[i+1] = vy[i] + DeltaT*ay\n    y[i+1] = y[i] + DeltaT*vy[i]\n    # update time to next time step and compute analytical answer\n    t[i+1] = t[i] + DeltaT\n    yanalytic[i+1] = y[0]-(vT*vT/g)*log(cosh(g*t[i+1]/vT))+vy[0]*t[i+1]\n    if ( y[i+1] < 0.0):\n        break\ndata = {'t[s]': t,\n        'Relative error in y': abs((y-yanalytic)/yanalytic),\n        'vy[m/s]': vy,\n        'x[m]': x,\n        'vx[m/s]': vx\n}\nNewData = pd.DataFrame(data)\ndisplay(NewData)\n# save to file\nNewData.to_csv(outfile, index=False)\n#then plot\nfig, axs = plt.subplots(4, 1)\naxs[0].plot(t, y)\naxs[0].set_xlim(0, tfinal)\naxs[0].set_ylabel('y')\naxs[1].plot(t, vy)\naxs[1].set_ylabel('vy[m/s]')\naxs[1].set_xlabel('time[s]')\naxs[2].plot(t, x)\naxs[2].set_xlim(0, tfinal)\naxs[2].set_ylabel('x')\naxs[3].plot(t, vx)\naxs[3].set_ylabel('vx[m/s]')\naxs[3].set_xlabel('time[s]')\nfig.tight_layout()\nsave_fig(\"EulerIntegration\")\nplt.show()\n\n\n# We see a good agreement with the analytical solution. This agreement\n# improves if we decrease $\\Delta t$. Furthermore, since we put the\n# initial velocity and position in the $x$ direction to zero, \n# the motion in the $x$-direction is\n# zero, as expected.\n\n# In[ ]:\n\n\n# Smarter way with declaration of vx, vy, x and y\n# Common imports\nimport numpy as np\nimport pandas as pd\nfrom math import *\nimport matplotlib.pyplot as plt\nimport os\n\n# Where to save the figures and data files\nPROJECT_ROOT_DIR = \"Results\"\nFIGURE_ID = \"Results/FigureFiles\"\nDATA_ID = \"DataFiles/\"\n\nif not os.path.exists(PROJECT_ROOT_DIR):\n    os.mkdir(PROJECT_ROOT_DIR)\n\nif not os.path.exists(FIGURE_ID):\n    os.makedirs(FIGURE_ID)\n\nif not os.path.exists(DATA_ID):\n    os.makedirs(DATA_ID)\n\ndef image_path(fig_id):\n    return os.path.join(FIGURE_ID, fig_id)\n\ndef data_path(dat_id):\n    return os.path.join(DATA_ID, dat_id)\n\ndef save_fig(fig_id):\n    plt.savefig(image_path(fig_id) + \".png\", format='png')\n\n\nfrom pylab import plt, mpl\nplt.style.use('seaborn')\nmpl.rcParams['font.family'] = 'serif'\n\ng = 9.80655 #m/s^2 g to 6 leading digits after decimal point\nD = 0.00245 #m/s\nm = 0.2 # kg\n# Define Gravitational force as a vector in x and y. It is a constant\nG = -m*g*np.array([0.0,1])\nDeltaT = 0.01\n#set up arrays \ntfinal = 1.3\nn = ceil(tfinal/DeltaT)\n# set up arrays for t, a, v, and x\nt = np.zeros(n)\nv = np.zeros((n,2))\nr = np.zeros((n,2))\n# Initial conditions as compact 2-dimensional arrays\nr0 = np.array([0.0,10.0])\nv0 = np.array([10.0,0.0])\nr[0] = r0\nv[0] = v0\n# Start integrating using Euler's method\nfor i in range(n-1):\n    # Set up forces, air resistance FD, not now that we need the norm of the vector\n    # Here you could have defined your own function for this\n    vabs = sqrt(sum(v[i]*v[i]))\n    FD = -D*v[i]*vabs\n    # Final net forces acting on falling object\n    Fnet = FD+G\n    # The accelration at a given time t_i\n    a = Fnet/m\n    # update velocity, time and position using Euler's method\n    v[i+1] = v[i] + DeltaT*a\n    r[i+1] = r[i] + DeltaT*v[i]\n    t[i+1] = t[i] + DeltaT\n\nfig, axs = plt.subplots(4, 1)\naxs[0].plot(t, r[:,1])\naxs[0].set_xlim(0, tfinal)\naxs[0].set_ylabel('y')\naxs[1].plot(t, v[:,1])\naxs[1].set_ylabel('vy[m/s]')\naxs[1].set_xlabel('time[s]')\naxs[2].plot(t, r[:,0])\naxs[2].set_xlim(0, tfinal)\naxs[2].set_ylabel('x')\naxs[3].plot(t, v[:,0])\naxs[3].set_ylabel('vx[m/s]')\naxs[3].set_xlabel('time[s]')\n\nfig.tight_layout()\nsave_fig(\"EulerIntegration\")\nplt.show()\n\n\n# Till now we have only introduced gravity and air resistance and studied\n# their effects via a constant acceleration due to gravity and the force\n# arising from air resistance. But what happens when the ball hits the\n# floor? What if we would like to simulate the normal force from the floor acting on the ball?\n# \n# We need then to include a force model for the normal force from\n# the floor on the ball. The simplest approach to such a system is to introduce a contact force\n# model represented by a spring model.  We model the interaction between the floor\n# and the ball as a single spring. But the normal force is zero when\n# there is no contact. Here  we define a simple model that allows us to include\n# such effects in our models.\n# \n# The normal force from the floor on the ball is represented by a spring force. This\n# is a strong simplification of the actual deformation process occurring at the contact\n# between the ball and the floor due to the deformation of both the ball and the floor.\n# \n# The deformed region corresponds roughly to the region of **overlap** between the\n# ball and the floor. The depth of this region is $\\Delta y = R − y(t)$, where $R$\n# is the radius of the ball. This is supposed to represent the compression of the spring.\n# Our model for the normal force acting on the ball is then\n\n# $$\n# \\boldsymbol{N} = −k (R − y(t)) \\boldsymbol{e}_y.\n# $$\n\n# The normal force must act upward when $y < R$,\n# hence the sign must be negative.\n# However, we must also ensure that the normal force only acts when the ball is in\n# contact with the floor, otherwise the normal force is zero. The full formation of the\n# normal force is therefore\n\n# $$\n# \\boldsymbol{N} = −k (R − y(t)) \\boldsymbol{e}_y,\n# $$\n\n# when $y(t) < R$ and zero when $y(t) \\le R$.\n# In the numerical calculations you can choose $R=0.1$ m and the spring constant $k=1000$ N/m.\n# \n# * Identify the forces acting on the ball and set up a diagram with the forces acting on the ball. Find the acceleration of the falling ball now with the normal force as well.\n# \n# * Choose a large enough final time so you can study the ball bouncing up and down several times. Add the normal force and compute the height of the ball as function of time with and without air resistance. Comment your results.\n# \n# The following code shows how\n# to set up the problem with gravitation, a drag force and a normal\n# force from the ground. The normal force makes the ball bounce up\n# again.\n# \n# \n# The code here includes all forces. Commenting out the air resistance will result in a ball which bounces up and down to the same height.\n# Furthermore, you will note that for larger values of $\\Delta t$ the results will not be physically meaningful. Can you figure out why?  Try also different values for the step size in order to see whether the final results agrees with what you expect.\n\n# In[ ]:\n\n\n# Smarter way with declaration of vx, vy, x and y\n# Here we have added a normal force from the ground\n# Common imports\nimport numpy as np\nimport pandas as pd\nfrom math import *\nimport matplotlib.pyplot as plt\nimport os\n\n# Where to save the figures and data files\nPROJECT_ROOT_DIR = \"Results\"\nFIGURE_ID = \"Results/FigureFiles\"\nDATA_ID = \"DataFiles/\"\n\nif not os.path.exists(PROJECT_ROOT_DIR):\n    os.mkdir(PROJECT_ROOT_DIR)\n\nif not os.path.exists(FIGURE_ID):\n    os.makedirs(FIGURE_ID)\n\nif not os.path.exists(DATA_ID):\n    os.makedirs(DATA_ID)\n\ndef image_path(fig_id):\n    return os.path.join(FIGURE_ID, fig_id)\n\ndef data_path(dat_id):\n    return os.path.join(DATA_ID, dat_id)\n\ndef save_fig(fig_id):\n    plt.savefig(image_path(fig_id) + \".png\", format='png')\n\n\nfrom pylab import plt, mpl\nplt.style.use('seaborn')\nmpl.rcParams['font.family'] = 'serif'\n\n# Define constants\ng = 9.80655 #in m/s^2\nD = 0.0245 # in mass/length, kg/m\nm = 0.2 # in kg\nR = 0.1 # in meters\nk = 1000.0 # in mass/time^2\n# Define Gravitational force as a vector in x and y, zero x component\nG = -m*g*np.array([0.0,1])\nDeltaT = 0.001\n#set up arrays \ntfinal = 15.0\nn = ceil(tfinal/DeltaT)\n# set up arrays for t, v, and r, the latter contain the x and y comps\nt = np.zeros(n)\nv = np.zeros((n,2))\nr = np.zeros((n,2))\n# Initial conditions\nr0 = np.array([0.0,2.0])\nv0 = np.array([10.0,10.0])\nr[0] = r0\nv[0] = v0\n# Start integrating using Euler's method\nfor i in range(n-1):\n    # Set up forces, air resistance FD\n    if ( r[i,1] < R):\n        N = k*(R-r[i,1])*np.array([0,1])\n    else:\n        N = np.array([0,0])\n    vabs = sqrt(sum(v[i]*v[i]))\n    FD = -D*v[i]*vabs\n    Fnet = FD+G+N\n    a = Fnet/m\n    # update velocity, time and position\n    v[i+1] = v[i] + DeltaT*a\n    r[i+1] = r[i] + DeltaT*v[i]\n    t[i+1] = t[i] + DeltaT\n\nfig, ax = plt.subplots()\nax.set_xlim(0, tfinal)\nax.set_ylabel('y[m]')\nax.set_xlabel('x[m]')\nax.plot(r[:,0], r[:,1])\nfig.tight_layout()\nsave_fig(\"BouncingBallEuler\")\nplt.show()\n\n", "meta": {"hexsha": "876d94f252377ade852c3e272145c046f8b146bf", "size": 72358, "ext": "py", "lang": "Python", "max_stars_repo_path": "doc/LectureNotes/_build/jupyter_execute/chapter3.py", "max_stars_repo_name": "Shield94/Physics321", "max_stars_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "doc/LectureNotes/_build/jupyter_execute/chapter3.py", "max_issues_repo_name": "Shield94/Physics321", "max_issues_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "doc/LectureNotes/_build/jupyter_execute/chapter3.py", "max_forks_repo_name": "Shield94/Physics321", "max_forks_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.3749440716, "max_line_length": 594, "alphanum_fraction": 0.6929572404, "include": true, "reason": "import numpy", "num_tokens": 21665, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3923368301671084, "lm_q2_score": 0.15610489744545739, "lm_q1q2_score": 0.061245700637312286}}
{"text": "# To add a new cell, type '# %%'\n# To add a new markdown cell, type '# %% [markdown]'\n# %% [markdown]\n# # 计算思维数据处理\n# %% [markdown]\n# 数据处理要求：\n# ### 1、每个题的平均作答时长；——结果数据\n# ### 2、每个题的编码种类（有多少种，分别是什么，每种多少学生）；——结果数据\n# 3、每个题的每个操作步骤的平均作答时长；——过程数据\n# ### 4、正确率（暂未提供标准编码，可以探索一下题目本身，协助形成标准答案编码）；——结果数据\n# 5、关键节点（通过数据，探索学生在从初始状态向终止状态进行的过程中，有几个关键步骤，每个关键步骤有几种类型的关键节点编码），体现“用数据说话”去探索关键节点。——过程数据\n# 6、每个题目的每种编码下，都有什么样的学生作答类型，比如都是正确的，但是可以聚成多少类，每一类有什么特征，学生是通过什么样的操作路径到达最终的。\n# ### 7、每道题目的正确率；——结果数据\n# \n# <font color=\"red\">注意 要求点四和要求点七相同，将一同分析\n# %% [markdown]\n# ## 0、数据加载和预处理\n# 首先读取数据，并通过pandas进行数据帧处理\n# 为了排版整洁和处理方便，以及保证工具的可拓展性，这里将处理工具封装成`data_analysis`的python类，并在jupyter中调用，该类在jupyter notebook同文件夹下的`main.py`文件中\n\n# %%\n# 首先引入需要的第三方库\nimport math\nimport pandas as pd\nimport json \nimport numpy as np\nimport ast\nfrom datetime import datetime\nfrom pandas.core import groupby\nimport plotly.graph_objs as go\nfrom plotly.offline import plot\nimport plotly.offline as offline\nfrom pandas.core.indexes import interval\nimport plotly.figure_factory as ff\npyolt=plot\nimport plotly.express as px\nimport math\nimport re\n\n# %%\n# 从main.py中引用对应的工具\nfrom main import data_analysis\n\n# %%\n# 尝试将不同学校分开分析\ndf_all = pd.read_excel('./data/ticket_user_mianyang.xlsx')  \n#%%\nschool_list = [tup[0] for tup in list(df_all.groupby('school'))][1:]                    # 这里从index=1开始向后取元素是为了避开demo \ndf_list = [tup[1].reset_index(drop=True) for tup in list(df_all.groupby('school'))][1:] # 注意将index重置\ndf_entity_list = [data_analysis(df = df, name = school_list[i]) for i, df in enumerate(df_list)]\n\n# %%\n# 计算正确率并输出结果到output\nfor df_en in df_entity_list:\n    df_en.calculate_acc()\n    df_en.output()\n\n# %%\n# 首先将excel文件读取为pandas的dataframe类型\n# 然后将该dataframe作为参数以初始化对应的数据处理工具，这里没有对excel文件进行预处理，\n#   超时数据已经删除，但是并没有对不同学校进行学生分类，所以命名为'df_all'\n# df_all = pd.read_excel('./data/ticket_user_mianyang.xlsx')  \n# dataframe并不直接对其进行处理，而是作为参数初始化一个类的实体，这样的好处是可以避免大量的代码冗余\n#    在对不同学校和不同数据行进行分类后处理时，只需要额外生成新的类的实体即可\n#    在这里对应所有数据行直接生成一个实体，命名为'df_all_entity'\n#    注意在参数里有一个命名为'name'的参数，这里是方便在调试过程中快速判断出问题的是哪个dataframe\ndf_all_entity =  data_analysis(df = df_all, name = 'all')\n# 该步骤运行时间较长，在32秒左右\n\n\n# %%\n# ## 每道题的编码种类和正确率分析\nprint(\"题目个数为：\",len(df_all_entity.count_df_list))\nprint(\"参与答题总次数：\",df_all_entity.row_num)\n\naccuracy_list, addition_list = df_all_entity.calculate_acc()\nprob_name_list = ['小松鼠跳柱子（1）','小松鼠跳柱子（2）','填充小石子（1）','填充小石子（2）','嵌套的矩形（1）','嵌套的矩形（2）','模式的复制（1）','模式的复制（2）','浇花（1）','浇花（2）','密码（1）','密码（2）','4进制编码（1）','4进制编码（2）','供水系统（1）','供水系统（2）', '对应的形状（1）','对应的形状（2）','滚筒（1）']\ndis_list = [(prob_name_list[i], acc) for i, acc in enumerate(accuracy_list)]\ndis_list\n\nprint('calculate done')\n\n# %%\n# 判断每一行中22个题目是否正确\n\ndef judge_all_data(df_all_entity, data_all, addition_list):\n    columns_list = []\n    for i, data in enumerate(data_all):\n        data = df_all_entity.content_to_str(data)\n        if i in [0,1,2,3]:\n            if data in addition_list[i].index:\n                columns_list.append(data)\n                columns_list.append(addition_list[i].loc[data, 'success'])\n            else:\n                columns_list.append(data)\n                columns_list.append('0')\n        elif i in [5,6,7,8,18,19]:\n            if data in addition_list[i-1].index:\n                columns_list.append(data)\n                columns_list.append(addition_list[i-1].loc[data, 'success'])\n            else:\n                columns_list.append(data)\n                columns_list.append('0')\n        elif i in [9]:\n            list_temp = ast.literal_eval(data)\n            if list_temp!=None and len(list_temp)==2 and type(list_temp[0])==str:\n                if list_temp[0][0:2] > list_temp[0][-2:]:\n                    list_temp[0] = list_temp[0][-2:] + '_' + list_temp[0][0:2]\n                if list_temp[1][0:2] > list_temp[1][-2:]:\n                    list_temp[1] = list_temp[1][-2:] + '_' + list_temp[1][0:2]\n                if list_temp[0] > list_temp[1]:\n                    list_temp =  str([list_temp[1], list_temp[0]])\n                else:\n                    list_temp =  str(list_temp)\n            else:\n                list_temp =  str(list_temp)\n\n            columns_list.append(list_temp)\n            if list_temp in addition_list[8].index:\n                columns_list.append(addition_list[8].loc[list_temp, 'success'])\n            else:\n                columns_list.append('0')\n            \n        elif i in [10]:\n            list_temp = ast.literal_eval(data)\n            if type(list_temp)==list and len(list_temp)>=1 and type(list_temp[0]) == str:\n                list_temp = [[int(rebuild_i) for rebuild_i in re.findall(r\"\\d+\", str(rebuild))] for rebuild in list_temp]\n                for list_mem in list_temp:\n                    list_mem.sort()\n                list_temp.sort()\n                list_temp = str([str(list_str[0]) + '_' + str(list_str[1]) for list_str in list_temp])\n                \n            else:\n                list_temp =  str(list_temp)\n            columns_list.append(list_temp)\n            if list_temp in addition_list[9].index:\n                columns_list.append(addition_list[9].loc[list_temp, 'success'])\n            else:\n                columns_list.append('0')\n            # columns_list.append(addition_list[i-1].loc[df_all_entity.content_to_str(data_all[i]), 'success'])\n        elif i in [11]:\n            list_temp = ast.literal_eval(data)\n            if list_temp!=None:\n                list_temp = \"\".join(re.findall(r\"\\d+\", str(list_temp)))\n            else:\n                list_temp =  ''\n            columns_list.append(list_temp)\n            if list_temp in addition_list[10].index:\n                columns_list.append(addition_list[10].loc[list_temp, 'success'])\n            else:\n                columns_list.append('0')\n            # columns_list.append(addition_list[i-1].loc[df_all_entity.content_to_str(data_all[i]), 'success'])\n        elif i in [12]:\n            list_temp = ast.literal_eval(data)\n            if list_temp!=None:\n                list_temp = \"\".join(re.findall(r\"\\d+\", str(list_temp)))\n            else:\n                list_temp =  ''\n\n            columns_list.append(list_temp)\n            if list_temp in addition_list[11].index:\n                columns_list.append(addition_list[11].loc[list_temp, 'success'])\n            else:\n                columns_list.append('0')\n            # columns_list.append(addition_list[i-1].loc[df_all_entity.content_to_str(data_all[i]), 'success'])\n        elif i in [13]:\n            list_temp = ast.literal_eval(data)\n            if list_temp!=None:\n                list_temp = \"\".join(re.findall(r\"\\d+\", str(list_temp)))\n            else:\n                list_temp = ''\n            columns_list.append(list_temp)\n            if list_temp in addition_list[12].index:\n                columns_list.append(addition_list[12].loc[list_temp, 'success'])\n            else:\n                columns_list.append('0')\n            # columns_list.append(addition_list[i-1].loc[df_all_entity.content_to_str(data_all[i]), 'success'])\n        elif i in [14]:\n            list_temp = ast.literal_eval(data)\n            if list_temp!=None:\n                list_temp = \"\".join(re.findall(r\"\\d+\", str(list_temp)))\n            else:\n                list_temp = ''\n            columns_list.append(list_temp)\n            if list_temp in addition_list[13].index:\n                columns_list.append(addition_list[13].loc[list_temp, 'success'])\n            else:\n                columns_list.append('0')\n            # columns_list.append(addition_list[i-1].loc[df_all_entity.content_to_str(data_all[i]), 'success'])\n        elif i in [15]:\n            list_temp = ast.literal_eval(data)\n            if list_temp!=None:\n                list_temp = \"\".join(re.findall(r\"\\d+\", str(list_temp)))\n            else:\n                list_temp = ''\n            columns_list.append(list_temp)\n            if list_temp in addition_list[14].index:\n                columns_list.append(addition_list[14].loc[list_temp, 'success'])\n            else:\n                columns_list.append('0')\n            # columns_list.append(addition_list[i-1].loc[df_all_entity.content_to_str(data_all[i]), 'success'])\n        elif i in [16]:\n            list_temp = ast.literal_eval(data)\n\n            if list_temp!=None:\n                list_temp = \"\".join(re.findall(r\"\\d+\", str(list_temp)))\n            else:\n                list_temp = ''\n            columns_list.append(list_temp)\n            if list_temp in addition_list[15].index:\n                columns_list.append(addition_list[15].loc[list_temp, 'success'])\n            else:\n                columns_list.append('0')\n            # columns_list.append(addition_list[i-1].loc[df_all_entity.content_to_str(data_all[i]), 'success'])\n        elif i in [17]:\n            list_temp = ast.literal_eval(data)\n            if list_temp!=None:\n                list_temp = \"\".join(re.findall(r\"\\d+\", str(list_temp)))\n            else:\n                list_temp = ''\n            columns_list.append(list_temp)\n            if list_temp in addition_list[16].index:\n                columns_list.append(addition_list[16].loc[list_temp, 'success'])\n            else:\n                columns_list.append('0')\n            # columns_list.append(addition_list[i-1].loc[df_all_entity.content_to_str(data_all[i]), 'success'])\n        \n        elif i in [4,20,21]:\n            columns_list.append(data)\n            columns_list.append('unknow')\n        \n    return columns_list\n\ndf_column_prob_index = df_all_entity.df.index\n\ndf_column_prob_columns = []\nfor pro in range(22):\n    df_column_prob_columns.append(str(pro))\n    df_column_prob_columns.append('success_'+str(pro))\n\nfor df in addition_list:\n    if 'list' in df.columns and 'success' in df.columns:\n        for row in df.index:\n            df._set_value(row,'list', str(df.loc[row, 'list']))\n        df.set_index('list', inplace = True)\n\ndf_column_prob_data = []\nfor row in df_all_entity.df.index:\n    data_all = df_all_entity.df.loc[row, 'ans']\n    if len(data_all) == 22:\n        df_column_prob_data.append(judge_all_data(df_all_entity, data_all, addition_list))\n    else:\n        df_column_prob_data.append(['None']*44)\n# for row in df_all_entity.df.index:\n#%%\ndf_column_prob = pd.DataFrame(index=df_all_entity.df.index, columns=df_column_prob_columns, data=df_column_prob_data)\ndf_column_prob.to_excel('./output/单个学生题目正确统计.xlsx')\ndf_all_entity.df.to_excel('./output/单个学生题目正确统计（学生附加信息，二者index相同）.xlsx')\npd.concat([df_all_entity.df, df_column_prob], axis=1).to_excel('./output/单个学生题目正确统计(合并).xlsx')\n#%%\n# 作答时间分析，在原数据上增加'interval'（做题时间）、'day'、'hour_start'、'hour_end'\ndata1 = list(df_all_entity.df.loc[:, 'start_time_float'])\nlayout={\"title\": \"学生用时分布\", \n                                       \"xaxis_title\": \"时间（24小时制）\",\n                                       \"yaxis_title\": \"学生个数\",\n                                       # x轴坐标倾斜60度\n                                       \"xaxis\": {\"tickangle\": 60}\n                                      }\n\n#数据组\nhist_data=[data1]\n\ngroup_labels=['做题时间分布']\nimport plotly.figure_factory as ff\nfig=ff.create_distplot(hist_data,group_labels,bin_size=1,histnorm = 'probability')\nfig['layout'].update(xaxis = dict(range = [0,24]))\nplot(fig,filename='./plot/每小时回答人数统计.html')\n\nhour_list = list(range(24))\nhour_count_list = []\nfor hour in hour_list:\n    hour_count_seq = df_all_entity.df.sort_values('start_hour').groupby('start_hour')['start_hour'].count()\n    if hour not in list(hour_count_seq.index):\n        hour_count_list.append(0)\n    else:\n        hour_count_list.append(hour_count_seq.loc[hour])\n\npd.DataFrame(index = hour_list, columns=['count'], data = hour_count_list).to_excel('./plot/每小时回答人数统计.xlsx')\n\n\n# %%\n# 正确率和编码个数绘图\n## 正确的编码个数\ndata1 = go.Bar(x = prob_name_list, y = [len(group.groupby('success').get_group('1')) if '1' in group.groupby('success').groups.keys() else 0 for group in df_all_entity.addition_list], name = '回答中正确编码的个数')\n\n## 错误编码的个数\ndata2 = go.Bar(x = prob_name_list, y = [len(group.groupby('success').get_group('0')) if '0' in group.groupby('success').groups.keys() else 0 for group in df_all_entity.addition_list], name = '回答中错误编码的个数')\n\n## 回答正确率\ndata3 = go.Bar(x = prob_name_list, y = accuracy_list, name = '回答正确率')\n\nsuccess_count = []\nfor df in addition_list:\n    if 'success' in df.columns:\n        if '1' in df.groupby('success').groups.keys():\n            success_count.append(df.groupby('success').get_group('1')['count'].sum())\n        else:\n            success_count.append(0)\n\nlayout={\"title\": \"不同题目的编码数量和正确率\", \n       \"xaxis_title\": \"题目编号\",\n       \"yaxis_title\": \"编码个数\",\n       # x轴坐标倾斜60度\n       \"xaxis\": {\"tickangle\": 60}\n      }\nfrom plotly.subplots import make_subplots\nfig = make_subplots(rows=3, cols=1)\nfig.append_trace(data1, row = 1, col = 1)\nfig.append_trace(data2, row = 2, col = 1)\nfig.append_trace(data3, row = 3, col = 1)\n\n# fig = go.Figure(data=[data1, data2, data3],layout=layout)\nplot(fig,filename=\"./plot/不同题目的编码数量和正确率.html\",auto_open=False,image='png',image_height=800,image_width=1500)\npd_list = []\nfor i, row in enumerate(data1.y):\n    pd_list.append([data1.y[i], data2.y[i], data3.y[i], success_count[i]])\n\npd.DataFrame(index=prob_name_list, columns=[data1.name, data2.name, data3.name, 'success_count'], data= pd_list).to_excel('./plot/不同题目的编码数量和正确率.xlsx')\n\n#%%\n\ndata1 = go.Bar(x = school_list, y = [np.mean(df.accuracy_list) for df in df_entity_list], name = '各个学校的平均正确率')\ndata2 = go.Bar(x = school_list, y = [df.row_num for df in df_entity_list], name = '各个学校的参加人数')\nlayout={\"title\": \"各个学校的平均正确率\", \n       \"xaxis_title\": \"学校名称\",\n       \"yaxis_title\": \"正确率\",\n       # x轴坐标倾斜60度\n       \"xaxis\": {\"tickangle\": 60}\n      }\nfrom plotly.subplots import make_subplots\nfig = make_subplots(rows=2, cols=1)\nfig.append_trace(data1, row = 1, col = 1)\nfig.append_trace(data2, row = 2, col = 1)\n\nplot(fig,filename=\"./plot/各个学校的平均正确率和参加人数.html\",auto_open=False,image='png',image_height=800,image_width=1500)\npd_list = []\nfor i, row in enumerate(data1.y):\n    pd_list.append([data1.y[i], data2.y[i]])\npd.DataFrame(index=school_list, columns=[data1.name, data2.name], data= pd_list).to_excel('./plot/各个学校的平均正确率和参加人数.xlsx')\n# %% [markdown]\n# # 正确答案编码\n# %%\n# 模拟第19题的答案编码，遍历所有答案\n# 所有可能的五角星（0,a）和三角形（1,b）组合\nseq_list = []\nfor i in range(8):\n    for j in range(int(math.pow(2,i+1))):\n        temp=str(bin(j))[2:].zfill(i+1).replace('0','a')\n        temp = temp.replace('1', 'b')\n        seq_list.append(temp)\n# 所有可能的长方形（1）和圆形（0）组合\ntrans_list = []\nfor i in range(3):\n    for j in range(int(math.pow(2,i+1))):\n        trans_list.append(str(bin(j))[2:].zfill(i+1))\n# 正确序列 \nverify_str = '10100010010'\nright_ans = []\ncnt = 0\nfor seq in seq_list:\n    for star in trans_list:\n        for trian in trans_list:\n            cnt +=1\n            if seq.replace('a', star).replace('b', trian) == verify_str:\n                right_ans.append([seq.replace('a','0').replace('b','1'), star, trian])\nright_ans\n# %%\n# 模拟滚筒（2）的过程，遍历所有的答案\n# \nimport math\ndef roll_one_time(first_dic, second_dic, verify_list):\n    max_length = len(verify_list)\n    line_list = [-1] * max_length\n    # first roll\n    for i in range(first_dic['start'], first_dic['end']+1):\n        line_list[i] = first_dic['color_list'][i % len(first_dic['color_list'])]\n\n    # second roll\n    for i in range(second_dic['start'], second_dic['end']+1):\n        line_list[i] = second_dic['color_list'][i % len(second_dic['color_list'])]\n    \n    is_right = True\n    for i, c in enumerate(line_list):\n        if c != verify_list[i]:\n            is_right = False\n            break\n    if is_right:\n        return is_right, [first_dic, second_dic]\n    else:\n        return is_right, []\n\n\ndef traverse_color(min_roll_length = 2, max_roll_length = 5, colors = [0,1,2]):\n    color_lists = []\n    for i in range(min_roll_length, max_roll_length+1):\n        for j in range(int(math.pow(len(colors), i))):\n            tmp_list = []\n            for k in range(i):\n                tmp_list.insert(0, colors[j % len(colors)]) \n                j = j // len(colors)\n            color_lists.append(tmp_list)\n    return color_lists\n\ndef traverse_position(start_bound = 0, end_bound = 15):\n    position_list = []\n    start_list = range(start_bound,end_bound+1)\n    end_list = range(start_bound,end_bound+1)\n    for s in start_list:\n        for e in end_list:\n            if e>s:\n                position_list.append((s, e))\n    return position_list\n\ndef traverse_roll(min_roll_length = 2, max_roll_length = 5, colors = [0,1,2], start_bound = 0, end_bound = 15):\n    roll_dic_list = []\n    for cl in traverse_color(min_roll_length, max_roll_length, colors):\n        for p in traverse_position(start_bound, end_bound):\n            if p[1]-p[0]+1>=len(cl):\n                tmp_dic = {'color_list':[], 'start':0, 'end':0}\n                tmp_dic['color_list']=cl\n                tmp_dic['start'] = p[0]\n                tmp_dic['end'] = p[1]\n                roll_dic_list.append(tmp_dic)\n    return roll_dic_list\n\n# %%\n# search from bottom to top\n\nposible_roll = traverse_roll()\nlen(posible_roll)\n\n# %%\nposible_colors = traverse_color()\nlen(posible_colors)\n\n# %%\nposible_position = traverse_position()\nlen(posible_position)\n# %%\n# 从最后一次滚筒开始找起（第二次）\nverify_list = [0, 1, 0, 1, 2, 2, 0, 1, 1, 2, 2, 0, 1, 1, 0, 1]\nline_list = [-1]*len(verify_list)\n\nposible_roll2_list = []\nfor roll2 in posible_roll:\n    \n    roll2_is_posible = True\n    for index in range(roll2['start'], roll2['end']+1):\n        if roll2['color_list'][((index-roll2['start']) % len(roll2['color_list']))] != verify_list[index]:\n            roll2_is_posible = False\n    if roll2_is_posible:\n        posible_roll2_list.append(roll2)\nlen(posible_roll2_list)\n\n# %%\n# 根据所有可能的roll2寻找roll1\nposible_roll1_roll2 = []\ncnt = 0\nfor roll2 in posible_roll2_list:\n    print(cnt)\n    cnt += 1\n    flag_list = [-1]*len(verify_list)\n    for index2 in range(roll2['start'], roll2['end']+1):\n        flag_list[index2] = -2\n    for roll1 in posible_roll:\n        flag_list_ = [i for i in flag_list]\n\n        roll1_is_posible = True\n        for index1 in range(roll1['start'], roll1['end']+1):\n            if flag_list_[index1] == -1:\n                flag_list_[index1] = -3\n        if -1 in flag_list_:\n            roll1_is_posible = False\n            continue\n\n        for index1 in range(roll1['start'], roll1['end']+1):\n            if roll1['color_list'][((index1-roll1['start']) % len(roll1['color_list']))] != verify_list[index1] and flag_list_[index1] == -3:\n                roll1_is_posible = False\n                break\n        if roll1_is_posible:\n            posible_roll1_roll2.append((roll1, roll2))\n\n\n# %%\nlen(posible_roll1_roll2)\n# %%\nposible_roll1_roll2\n# %% [markdown]\n# 所有可能的答案：\n'''python\nposible_roll1_roll2\n[({'color_list': [0, 1], 'start': 0, 'end': 15},\n  {'color_list': [1, 2, 2, 0, 1], 'start': 3, 'end': 12}),\n ({'color_list': [0, 1, 0, 1], 'start': 0, 'end': 15},\n  {'color_list': [1, 2, 2, 0, 1], 'start': 3, 'end': 12}),\n ({'color_list': [0, 1], 'start': 0, 'end': 15},\n  {'color_list': [1, 2, 2, 0, 1], 'start': 3, 'end': 13}),\n ({'color_list': [0, 1, 0, 1], 'start': 0, 'end': 15},\n  {'color_list': [1, 2, 2, 0, 1], 'start': 3, 'end': 13}),\n ({'color_list': [0, 1], 'start': 0, 'end': 15},\n  {'color_list': [2, 2, 0, 1, 1], 'start': 4, 'end': 12}),\n ({'color_list': [0, 1, 0, 1], 'start': 0, 'end': 15},\n  {'color_list': [2, 2, 0, 1, 1], 'start': 4, 'end': 12}),\n ({'color_list': [0, 1], 'start': 0, 'end': 15},\n  {'color_list': [2, 2, 0, 1, 1], 'start': 4, 'end': 13}),\n ({'color_list': [0, 1, 0, 1], 'start': 0, 'end': 15},\n  {'color_list': [2, 2, 0, 1, 1], 'start': 4, 'end': 13})]\n'''\n\n#%% \n# 对于滚筒（3），遍历的计算复杂度太高，这里只给出验证函数\ndef verify_roll_3(roll1, roll2, roll3, verify_list = [1,0,1,2,1,0,2,2,1,2,0,1,2,0,2,2,1,0,2,0]):\n    flag_list = [-1]*len(verify_list)\n    for index3 in range(roll3['start'], roll3['end']+1):\n        if verify_list[index3] != roll3['color_list'][((index3-roll3['start']) % len(roll3['color_list']))]:\n            return False\n        flag_list[index3] = '3'\n    \n    for index2 in range(roll2['start'], roll2['end']+1):\n        if flag_list[index2] == -1:\n            if verify_list[index2] != roll2['color_list'][((index2-roll2['start']) % len(roll2['color_list']))]:\n                return False\n            flag_list[index2] = '2'\n    \n    for index1 in range(roll1['start'], roll1['end']+1):\n        if flag_list[index1] == -1:\n            if verify_list[index1] != roll1['color_list'][((index1-roll1['start']) % len(roll1['color_list']))]:\n                return False\n            flag_list[index1] = '1'\n    \n    if -1 in flag_list:\n        return False\n    else:\n        return True\n\n#%%\nposible_roll = traverse_roll(min_roll_length = 2, max_roll_length = 4, colors = [0,1,2], start_bound = 0, end_bound = 19)\nlen(posible_roll)\n\n#%%\n# 从最后一次滚筒开始找起（第三次）\nverify_list = [1,0,1,2,1,0,2,2,1,2,0,1,2,0,2,2,1,0,2,0]\nline_list = [-1]*len(verify_list)\n\nposible_roll3_list = []\nfor roll3 in posible_roll:\n    \n    roll3_is_posible = True\n    for index in range(roll3['start'], roll3['end']+1):\n        if roll3['color_list'][((index-roll3['start']) % len(roll3['color_list']))] != verify_list[index]:\n            roll3_is_posible = False\n    if roll3_is_posible:\n        posible_roll3_list.append(roll3)\nlen(posible_roll3_list)\n\n#%%\n# 根据所有可能的roll3寻找roll2\nposible_roll2_roll3 = []\ncnt = 0\nfor roll3 in posible_roll3_list:\n    print(cnt)\n    cnt += 1\n    flag_list = [-1]*len(verify_list)\n    for index3 in range(roll3['start'], roll3['end']+1):\n        flag_list[index3] = '3'\n    for roll2 in posible_roll:\n        flag_list_ = [i for i in flag_list]\n\n        roll2_is_posible = True\n\n        # if roll2['start']>=roll3['start'] and roll2['end']<=roll3['end']:\n        #     roll2_is_posible = False\n        #     continue\n\n        for index2 in range(roll2['start'], roll2['end']+1):\n            if flag_list_[index2] == -1 and roll2['color_list'][(index2-roll2['start']) % len(roll2['color_list'])] != verify_list[index2]:\n                roll2_is_posible = False\n                break\n\n        if roll2_is_posible:\n            posible_roll2_roll3.append((roll2, roll3))\n\n# %%\nlen(posible_roll2_roll3)\n# %%\nverify_list = [1,0,1,2,1,0,2,2,1,2,0,1,2,0,2,2,1,0,2,0]\nall_right_ans=[]\ncnt = 0\nfor roll23 in posible_roll2_roll3:\n    print(cnt,len(all_right_ans))\n    cnt+=1\n    for roll1 in posible_roll:\n        if min([roll1['start'], roll23[0]['start'], roll23[1]['start']])!=0 or max([roll1['end'], roll23[0]['end'], roll23[1]['end']])!=len(verify_list)-1:\n            continue\n        if verify_roll_3(roll1, roll23[0], roll23[1], verify_list):\n            all_right_ans.append((roll1, roll23[0], roll23[1]))\n\n# %%\nlen(all_right_ans)\n# %%\nall_right_ans\n# %% [markdown]\n## 共有15种正确答案\n'''python\n[({'color_list': [1, 0], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [1, 2, 0], 'start': 8, 'end': 12}),\n ({'color_list': [1, 0, 1], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [1, 2, 0], 'start': 8, 'end': 12}),\n ({'color_list': [1, 0, 1, 0], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [1, 2, 0], 'start': 8, 'end': 12}),\n ({'color_list': [1, 0], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [1, 2, 0], 'start': 8, 'end': 13}),\n ({'color_list': [1, 0, 1], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [1, 2, 0], 'start': 8, 'end': 13}),\n ({'color_list': [1, 0, 1, 0], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [1, 2, 0], 'start': 8, 'end': 13}),\n ({'color_list': [1, 0], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [2, 0, 1], 'start': 9, 'end': 12}),\n ({'color_list': [1, 0, 1], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [2, 0, 1], 'start': 9, 'end': 12}),\n ({'color_list': [1, 0, 1, 0], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [2, 0, 1], 'start': 9, 'end': 12}),\n ({'color_list': [1, 0], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [2, 0, 1], 'start': 9, 'end': 13}),\n ({'color_list': [1, 0, 1], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [2, 0, 1], 'start': 9, 'end': 13}),\n ({'color_list': [1, 0, 1, 0], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [2, 0, 1], 'start': 9, 'end': 13}),\n ({'color_list': [1, 0], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [2, 0, 1, 2], 'start': 9, 'end': 12}),\n ({'color_list': [1, 0, 1], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [2, 0, 1, 2], 'start': 9, 'end': 12}),\n ({'color_list': [1, 0, 1, 0], 'start': 0, 'end': 19},\n  {'color_list': [2, 1, 0, 2], 'start': 3, 'end': 18},\n  {'color_list': [2, 0, 1, 2], 'start': 9, 'end': 12})]\n'''", "meta": {"hexsha": "2227fd678beac626327c37ec6287b7724102e11e", "size": 25080, "ext": "py", "lang": "Python", "max_stars_repo_path": "20210803/main_run.py", "max_stars_repo_name": "Brook1711/openda1", "max_stars_repo_head_hexsha": "1d67912083ecf60b04daa6d9cf377339d179b1aa", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "20210803/main_run.py", "max_issues_repo_name": "Brook1711/openda1", "max_issues_repo_head_hexsha": "1d67912083ecf60b04daa6d9cf377339d179b1aa", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "20210803/main_run.py", "max_forks_repo_name": "Brook1711/openda1", "max_forks_repo_head_hexsha": "1d67912083ecf60b04daa6d9cf377339d179b1aa", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.0, "max_line_length": 213, "alphanum_fraction": 0.5925438596, "include": true, "reason": "import numpy", "num_tokens": 8490, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4726834914771176, "lm_q2_score": 0.12940273494909915, "lm_q1q2_score": 0.061166536562428216}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Project 3: Smart Beta Portfolio and Portfolio Optimization\n# \n# ## Overview\n# \n# \n# Smart beta has a broad meaning, but we can say in practice that when we use the universe of stocks from an index, and then apply some weighting scheme other than market cap weighting, it can be considered a type of smart beta fund.  A Smart Beta portfolio generally gives investors exposure or \"beta\" to one or more types of market characteristics (or factors) that are believed to predict prices while giving investors a diversified broad exposure to a particular market. Smart Beta portfolios generally target momentum, earnings quality, low volatility, and dividends or some combination. Smart Beta Portfolios are generally rebalanced infrequently and follow relatively simple rules or algorithms that are passively managed.  Model changes to these types of funds are also rare requiring prospectus filings with US Security and Exchange Commission in the case of US focused mutual funds or ETFs.. Smart Beta portfolios are generally long-only, they do not short stocks.\n# \n# In contrast, a purely alpha-focused quantitative fund may use multiple models or algorithms to create a portfolio. The portfolio manager retains discretion in upgrading or changing the types of models and how often to rebalance the portfolio in attempt to maximize performance in comparison to a stock benchmark.  Managers may have discretion to short stocks in portfolios.\n# \n# Imagine you're a portfolio manager, and wish to try out some different portfolio weighting methods.\n# \n# One way to design portfolio is to look at certain accounting measures (fundamentals) that, based on past trends, indicate stocks that produce better results.  \n# \n# \n# For instance, you may start with a hypothesis that dividend-issuing stocks tend to perform better than stocks that do not. This may not always be true of all companies; for instance, Apple does not issue dividends, but has had good historical performance.  The hypothesis about dividend-paying stocks may go something like this: \n# \n# Companies that regularly issue dividends may also be more prudent in allocating their available cash, and may indicate that they are more conscious of prioritizing shareholder interests.  For example, a CEO may decide to reinvest cash into pet projects that produce low returns.  Or, the CEO may do some analysis, identify that reinvesting within the company produces lower returns compared to a diversified portfolio, and so decide that shareholders would be better served if they were given the cash (in the form of dividends).  So according to this hypothesis, dividends may be both a proxy for how the company is doing (in terms of earnings and cash flow), but also a signal that the company acts in the best interest of its shareholders.  Of course, it's important to test whether this works in practice.\n# \n# \n# You may also have another hypothesis, with which you wish to design a portfolio that can then be made into an ETF.  You may find that investors may wish to invest in passive beta funds, but wish to have less risk exposure (less volatility) in their investments.  The goal of having a low volatility fund that still produces returns similar to an index may be appealing to investors who have a shorter investment time horizon, and so are more risk averse.\n# \n# So the objective of your proposed portfolio is to design a portfolio that closely tracks an index, while also minimizing the portfolio variance.  Also, if this portfolio can match the returns of the index with less volatility, then it has a higher risk-adjusted return (same return, lower volatility).\n# \n# Smart Beta ETFs can be designed with both of these two general methods (among others): alternative weighting and minimum volatility ETF.\n# \n# \n# ## Instructions\n# Each problem consists of a function to implement and instructions on how to implement the function.  The parts of the function that need to be implemented are marked with a `# TODO` comment. After implementing the function, run the cell to test it against the unit tests we've provided. For each problem, we provide one or more unit tests from our `project_tests` package. These unit tests won't tell you if your answer is correct, but will warn you of any major errors. Your code will be checked for the correct solution when you submit it to Udacity.\n# \n# ## Packages\n# When you implement the functions, you'll only need to you use the packages you've used in the classroom, like [Pandas](https://pandas.pydata.org/) and [Numpy](http://www.numpy.org/). These packages will be imported for you. We recommend you don't add any import statements, otherwise the grader might not be able to run your code.\n# \n# The other packages that we're importing are `helper`, `project_helper`, and `project_tests`. These are custom packages built to help you solve the problems.  The `helper` and `project_helper` module contains utility functions and graph functions. The `project_tests` contains the unit tests for all the problems.\n# ### Install Packages\n\n# In[1]:\n\n\nimport sys\nget_ipython().system('{sys.executable} -m pip install -r requirements.txt')\n\n\n# In[2]:\n\n\nimport pandas as pd\nimport numpy as np\nimport helper\nimport project_helper\nimport project_tests\n\n\n# \n# ### Load Packages\n\n# ## Market Data\n# ### Load Data\n# For this universe of stocks, we'll be selecting large dollar volume stocks. We're using this universe, since it is highly liquid.\n\n# In[3]:\n\n\ndf = pd.read_csv('../../data/project_3/eod-quotemedia.csv')\n\npercent_top_dollar = 0.2\nhigh_volume_symbols = project_helper.large_dollar_volume_stocks(df, 'adj_close', 'adj_volume', percent_top_dollar)\ndf = df[df['ticker'].isin(high_volume_symbols)]\n\nclose = df.reset_index().pivot(index='date', columns='ticker', values='adj_close')\nvolume = df.reset_index().pivot(index='date', columns='ticker', values='adj_volume')\ndividends = df.reset_index().pivot(index='date', columns='ticker', values='dividends')\n\n\n# ### View Data\n# To see what one of these 2-d matrices looks like, let's take a look at the closing prices matrix.\n\n# In[4]:\n\n\nproject_helper.print_dataframe(close)\n\n\n# # Part 1: Smart Beta Portfolio\n# In Part 1 of this project, you'll build a portfolio using dividend yield to choose the portfolio weights. A portfolio such as this could be incorporated into a smart beta ETF.  You'll compare this portfolio to a market cap weighted index to see how well it performs. \n# \n# Note that in practice, you'll probably get the index weights from a data vendor (such as companies that create indices, like MSCI, FTSE, Standard and Poor's), but for this exercise we will simulate a market cap weighted index.\n# \n# ## Index Weights\n# The index we'll be using is based on large dollar volume stocks. Implement `generate_dollar_volume_weights` to generate the weights for this index. For each date, generate the weights based on dollar volume traded for that date. For example, assume the following is close prices and volume data:\n# ```\n#                  Prices\n#                A         B         ...\n# 2013-07-08     2         2         ...\n# 2013-07-09     5         6         ...\n# 2013-07-10     1         2         ...\n# 2013-07-11     6         5         ...\n# ...            ...       ...       ...\n# \n#                  Volume\n#                A         B         ...\n# 2013-07-08     100       340       ...\n# 2013-07-09     240       220       ...\n# 2013-07-10     120       500       ...\n# 2013-07-11     10        100       ...\n# ...            ...       ...       ...\n# ```\n# The weights created from the function `generate_dollar_volume_weights` should be the following:\n# ```\n#                A         B         ...\n# 2013-07-08     0.126..   0.194..   ...\n# 2013-07-09     0.759..   0.377..   ...\n# 2013-07-10     0.075..   0.285..   ...\n# 2013-07-11     0.037..   0.142..   ...\n# ...            ...       ...       ...\n# ```\n\n# In[5]:\n\n\ndef generate_dollar_volume_weights(close, volume):\n    \"\"\"\n    Generate dollar volume weights.\n\n    Parameters\n    ----------\n    close : DataFrame\n        Close price for each ticker and date\n    volume : str\n        Volume for each ticker and date\n\n    Returns\n    -------\n    dollar_volume_weights : DataFrame\n        The dollar volume weights for each ticker and date\n    \"\"\"\n    \n    product = close*volume \n    \n    \n        \n    weights=product.apply(lambda r : r/sum(r),axis=1)  \n    \n    assert close.index.equals(volume.index)\n    assert close.columns.equals(volume.columns)\n    \n    #TODO: Implement function\n\n    return weights\n\nproject_tests.test_generate_dollar_volume_weights(generate_dollar_volume_weights)\n\n\n# ### View Data\n# Let's generate the index weights using `generate_dollar_volume_weights` and view them using a heatmap.\n\n# In[6]:\n\n\nindex_weights = generate_dollar_volume_weights(close, volume)\nproject_helper.plot_weights(index_weights, 'Index Weights')\n\n\n# ## Portfolio Weights\n# Now that we have the index weights, let's choose the portfolio weights based on dividend. You would normally calculate the weights based on trailing dividend yield, but we'll simplify this by just calculating the total dividend yield over time.\n# \n# Implement `calculate_dividend_weights` to return the weights for each stock based on its total dividend yield over time. This is similar to generating the weight for the index, but it's using dividend data instead.\n# For example, assume the following is `dividends` data:\n# ```\n#                  Prices\n#                A         B\n# 2013-07-08     0         0\n# 2013-07-09     0         1\n# 2013-07-10     0.5       0\n# 2013-07-11     0         0\n# 2013-07-12     2         0\n# ...            ...       ...\n# ```\n# The weights created from the function `calculate_dividend_weights` should be the following:\n# ```\n#                A         B\n# 2013-07-08     NaN       NaN\n# 2013-07-09     0         1\n# 2013-07-10     0.333..   0.666..\n# 2013-07-11     0.333..   0.666..\n# 2013-07-12     0.714..   0.285..\n# ...            ...       ...\n# ```\n\n# In[7]:\n\n\ndef calculate_dividend_weights(dividends):\n    \n    \"\"\"\n    Calculate dividend weights.\n\n    Parameters\n    ----------\n    dividends : DataFrame\n        Dividend for each stock and date\n\n    Returns\n    -------\n    dividend_weights : DataFrame\n        Weights for each stock and date\n    \"\"\"\n    #TODO: Implement function\n    divs=dividends.copy()\n\n    weights_r=divs.cumsum()\n    \n    weights=weights_r.apply((lambda x: x/sum(x)),axis=1)\n    return weights\n\nproject_tests.test_calculate_dividend_weights(calculate_dividend_weights)\n\n\n# ### View Data\n# Just like the index weights, let's generate the ETF weights and view them using a heatmap.\n\n# In[8]:\n\n\netf_weights = calculate_dividend_weights(dividends)\nproject_helper.plot_weights(etf_weights, 'ETF Weights')\n\n\n# ## Returns\n# Implement `generate_returns` to generate returns data for all the stocks and dates from price data. You might notice we're implementing returns and not log returns. Since we're not dealing with volatility, we don't have to use log returns.\n\n# In[9]:\n\n\ndef generate_returns(prices):\n    \"\"\"\n    Generate returns for ticker and date.\n\n    Parameters\n    ----------\n    prices : DataFrame\n        Price for each ticker and date\n\n    Returns\n    -------\n    returns : Dataframe\n        The returns for each ticker and date\n    \"\"\"\n    r=prices.copy()\n    \n    d=r.shift(1)\n    \n    returns=(r-d)/d\n    \n    \n    #TODO: Implement function\n\n    return returns\n\nproject_tests.test_generate_returns(generate_returns)\n\n\n# ### View Data\n# Let's generate the closing returns using `generate_returns` and view them using a heatmap.\n\n# In[10]:\n\n\nreturns = generate_returns(close)\nproject_helper.plot_returns(returns, 'Close Returns')\n\n\n# ## Weighted Returns\n# With the returns of each stock computed, we can use it to compute the returns for an index or ETF. Implement `generate_weighted_returns` to create weighted returns using the returns and weights.\n\n# In[11]:\n\n\ndef generate_weighted_returns(returns, weights):\n    \"\"\"\n    Generate weighted returns.\n\n    Parameters\n    ----------\n    returns : DataFrame\n        Returns for each ticker and date\n    weights : DataFrame\n        Weights for each ticker and date\n\n    Returns\n    -------\n    weighted_returns : DataFrame\n        Weighted returns for each ticker and date\n    \"\"\"\n    weighted_returns=returns*weights\n    \n    assert returns.index.equals(weights.index)\n    assert returns.columns.equals(weights.columns)\n    \n    #TODO: Implement function\n\n    return weighted_returns\n\nproject_tests.test_generate_weighted_returns(generate_weighted_returns)\n\n\n# ### View Data\n# Let's generate the ETF and index returns using `generate_weighted_returns` and view them using a heatmap.\n\n# In[12]:\n\n\nindex_weighted_returns = generate_weighted_returns(returns, index_weights)\netf_weighted_returns = generate_weighted_returns(returns, etf_weights)\nproject_helper.plot_returns(index_weighted_returns, 'Index Returns')\nproject_helper.plot_returns(etf_weighted_returns, 'ETF Returns')\n\n\n# ## Cumulative Returns\n# To compare performance between the ETF and Index, we're going to calculate the tracking error. Before we do that, we first need to calculate the index and ETF comulative returns. Implement `calculate_cumulative_returns` to calculate the cumulative returns over time given the returns.\n\n# In[13]:\n\n\ndef calculate_cumulative_returns(returns):\n    \"\"\"\n    Calculate cumulative returns.\n\n    Parameters\n    ----------\n    returns : DataFrame\n        Returns for each ticker and date\n\n    Returns\n    -------\n    cumulative_returns : Pandas Series\n        Cumulative returns for each date\n    \"\"\"\n    r=returns.sum(axis=1)\n    ret=r.apply(lambda x: x+1)\n    cum_ret=ret.cumprod()\n    #TODO: Implement function\n    \n    return cum_ret\n\nproject_tests.test_calculate_cumulative_returns(calculate_cumulative_returns)\n\n\n# ### View Data\n# Let's generate the ETF and index cumulative returns using `calculate_cumulative_returns` and compare the two.\n\n# In[14]:\n\n\nindex_weighted_cumulative_returns = calculate_cumulative_returns(index_weighted_returns)\netf_weighted_cumulative_returns = calculate_cumulative_returns(etf_weighted_returns)\nproject_helper.plot_benchmark_returns(index_weighted_cumulative_returns, etf_weighted_cumulative_returns, 'Smart Beta ETF vs Index')\n\n\n# ## Tracking Error\n# In order to check the performance of the smart beta portfolio, we can calculate the annualized tracking error against the index. Implement `tracking_error` to return the tracking error between the ETF and benchmark.\n# \n# For reference, we'll be using the following annualized tracking error function:\n# $$ TE = \\sqrt{252} * SampleStdev(r_p - r_b) $$\n# \n# Where $ r_p $ is the portfolio/ETF returns and $ r_b $ is the benchmark returns.\n# \n# _Note: When calculating the sample standard deviation, the delta degrees of freedom is 1, which is the also the default value._\n\n# In[15]:\n\n\ndef tracking_error(benchmark_returns_by_date, etf_returns_by_date):\n    \"\"\"\n    Calculate the tracking error.\n\n    Parameters\n    ----------\n    benchmark_returns_by_date : Pandas Series\n        The benchmark returns for each date\n    etf_returns_by_date : Pandas Series\n        The ETF returns for each date\n\n    Returns\n    -------\n    tracking_error : float\n        The tracking error\n    \"\"\"\n    series_ret=(etf_returns_by_date)-(benchmark_returns_by_date)\n    stdev=series_ret.std()\n    Tracking_error=np.sqrt(252)*stdev\n    assert benchmark_returns_by_date.index.equals(etf_returns_by_date.index)\n    \n    #TODO: Implement function\n\n    return Tracking_error\n\nproject_tests.test_tracking_error(tracking_error)\n\n\n# ### View Data\n# Let's generate the tracking error using `tracking_error`.\n\n# In[16]:\n\n\nsmart_beta_tracking_error = tracking_error(np.sum(index_weighted_returns, 1), np.sum(etf_weighted_returns, 1))\nprint('Smart Beta Tracking Error: {}'.format(smart_beta_tracking_error))\n\n\n# # Part 2: Portfolio Optimization\n# \n# Now, let's create a second portfolio.  We'll still reuse the market cap weighted index, but this will be independent of the dividend-weighted portfolio that we created in part 1.\n# \n# We want to both minimize the portfolio variance and also want to closely track a market cap weighted index.  In other words, we're trying to minimize the distance between the weights of our portfolio and the weights of the index.\n# \n# $Minimize \\left [ \\sigma^2_p + \\lambda \\sqrt{\\sum_{1}^{m}(weight_i - indexWeight_i)^2} \\right  ]$ where $m$ is the number of stocks in the portfolio, and $\\lambda$ is a scaling factor that you can choose.\n# \n# Why are we doing this? One way that investors evaluate a fund is by how well it tracks its index. The fund is still expected to deviate from the index within a certain range in order to improve fund performance.  A way for a fund to track the performance of its benchmark is by keeping its asset weights similar to the weights of the index.  We’d expect that if the fund has the same stocks as the benchmark, and also the same weights for each stock as the benchmark, the fund would yield about the same returns as the benchmark. By minimizing a linear combination of both the portfolio risk and distance between portfolio and benchmark weights, we attempt to balance the desire to minimize portfolio variance with the goal of tracking the index.\n# \n# \n# ## Covariance\n# Implement `get_covariance_returns` to calculate the covariance of the `returns`. We'll use this to calculate the portfolio variance.\n# \n# If we have $m$ stock series, the covariance matrix is an $m \\times m$ matrix containing the covariance between each pair of stocks.  We can use [`Numpy.cov`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.cov.html) to get the covariance.  We give it a 2D array in which each row is a stock series, and each column is an observation at the same period of time. For any `NaN` values, you can replace them with zeros using the [`DataFrame.fillna`](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.fillna.html) function.\n# \n# The covariance matrix $\\mathbf{P} = \n# \\begin{bmatrix}\n# \\sigma^2_{1,1} & ... & \\sigma^2_{1,m} \\\\ \n# ... & ... & ...\\\\\n# \\sigma_{m,1} & ... & \\sigma^2_{m,m}  \\\\\n# \\end{bmatrix}$\n\n# In[17]:\n\n\ndef get_covariance_returns(returns):\n    \"\"\"\n    Calculate covariance matrices.\n\n    Parameters\n    ----------\n    returns : DataFrame\n        Returns for each ticker and date\n\n    Returns\n    -------\n    returns_covariance  : 2 dimensional Ndarray\n        The covariance of the returns\n    \"\"\"\n    #TODO: Implement function\n    \n    cov=returns.fillna(0)\n    \n    return np.cov(cov,rowvar=False)\n\nproject_tests.test_get_covariance_returns(get_covariance_returns)\n\n\n# ### View Data\n# Let's look at the covariance generated from `get_covariance_returns`.\n\n# In[18]:\n\n\ncovariance_returns = get_covariance_returns(returns)\ncovariance_returns = pd.DataFrame(covariance_returns, returns.columns, returns.columns)\n\ncovariance_returns_correlation = np.linalg.inv(np.diag(np.sqrt(np.diag(covariance_returns))))\ncovariance_returns_correlation = pd.DataFrame(\n    covariance_returns_correlation.dot(covariance_returns).dot(covariance_returns_correlation),\n    covariance_returns.index,\n    covariance_returns.columns)\n\nproject_helper.plot_covariance_returns_correlation(\n    covariance_returns_correlation,\n    'Covariance Returns Correlation Matrix')\n\n\n# ### portfolio variance\n# We can write the portfolio variance $\\sigma^2_p = \\mathbf{x^T} \\mathbf{P} \\mathbf{x}$\n# \n# Recall that the $\\mathbf{x^T} \\mathbf{P} \\mathbf{x}$ is called the quadratic form.\n# We can use the cvxpy function `quad_form(x,P)` to get the quadratic form.\n# \n# ### Distance from index weights\n# We want portfolio weights that track the index closely.  So we want to minimize the distance between them.\n# Recall from the Pythagorean theorem that you can get the distance between two points in an x,y plane by adding the square of the x and y distances and taking the square root.  Extending this to any number of dimensions is called the L2 norm.  So: $\\sqrt{\\sum_{1}^{n}(weight_i - indexWeight_i)^2}$  Can also be written as $\\left \\| \\mathbf{x} - \\mathbf{index} \\right \\|_2$.  There's a cvxpy function called [norm()](https://www.cvxpy.org/api_reference/cvxpy.atoms.other_atoms.html#norm)\n# `norm(x, p=2, axis=None)`.  The default is already set to find an L2 norm, so you would pass in one argument, which is the difference between your portfolio weights and the index weights.\n# \n# ### objective function\n# We want to minimize both the portfolio variance and the distance of the portfolio weights from the index weights.\n# We also want to choose a `scale` constant, which is $\\lambda$ in the expression. \n# \n# $\\mathbf{x^T} \\mathbf{P} \\mathbf{x} + \\lambda \\left \\| \\mathbf{x} - \\mathbf{index} \\right \\|_2$\n# \n# \n# This lets us choose how much priority we give to minimizing the difference from the index, relative to minimizing the variance of the portfolio.  If you choose a higher value for `scale` ($\\lambda$).\n# \n# We can find the objective function using cvxpy `objective = cvx.Minimize()`.  Can you guess what to pass into this function?\n# \n# \n\n# ### constraints\n# We can also define our constraints in a list.  For example, you'd want the weights to sum to one. So $\\sum_{1}^{n}x = 1$.  You may also need to go long only, which means no shorting, so no negative weights.  So $x_i >0 $ for all $i$. you could save a variable as `[x >= 0, sum(x) == 1]`, where x was created using `cvx.Variable()`.\n# \n# ### optimization\n# So now that we have our objective function and constraints, we can solve for the values of $\\mathbf{x}$.\n# cvxpy has the constructor `Problem(objective, constraints)`, which returns a `Problem` object.\n# \n# The `Problem` object has a function solve(), which returns the minimum of the solution.  In this case, this is the minimum variance of the portfolio.\n# \n# It also updates the vector $\\mathbf{x}$.\n# \n# We can check out the values of $x_A$ and $x_B$ that gave the minimum portfolio variance by using `x.value`\n\n# In[19]:\n\n\nimport cvxpy as cvx\n\ndef get_optimal_weights(covariance_returns, index_weights, scale=2.0):\n    \"\"\"\n    Find the optimal weights.\n\n    Parameters\n    ----------\n    covariance_returns : 2 dimensional Ndarray\n        The covariance of the returns\n    index_weights : Pandas Series\n        Index weights for all tickers at a period in time\n    scale : int\n        The penalty factor for weights the deviate from the index \n    Returns\n    -------\n    x : 1 dimensional Ndarray\n        The solution for x\n    \"\"\"\n    \n    m=index_weights.shape[0]\n    \n    x=cvx.Variable(m)\n    \n    p = covariance_returns\n    \n    portfolio_variance = cvx.quad_form(x,p)\n    \n    diff=(x-index_weights)\n    \n    dist=cvx.norm(diff,p=2,axis=None)\n    \n    objective = cvx.Minimize(portfolio_variance + scale*(dist))\n    \n    constraints = [x >= 0 , sum(x) == 1]\n    \n    problem= cvx.Problem(objective,constraints)\n    \n    solved= problem.solve()\n    \n    x_vals= x.value\n    \n    assert len(covariance_returns.shape) == 2\n    assert len(index_weights.shape) == 1\n    assert covariance_returns.shape[0] == covariance_returns.shape[1]  == index_weights.shape[0]\n\n    #TODO: Implement function\n    \n    return x_vals\n\nproject_tests.test_get_optimal_weights(get_optimal_weights)\n\n\n# ## Optimized Portfolio\n# Using the `get_optimal_weights` function, let's generate the optimal ETF weights without rebalanceing. We can do this by feeding in the covariance of the entire history of data. We also need to feed in a set of index weights. We'll go with the average weights of the index over time.\n\n# In[20]:\n\n\nraw_optimal_single_rebalance_etf_weights = get_optimal_weights(covariance_returns.values, index_weights.iloc[-1])\noptimal_single_rebalance_etf_weights = pd.DataFrame(\n    np.tile(raw_optimal_single_rebalance_etf_weights, (len(returns.index), 1)),\n    returns.index,\n    returns.columns)\n\n\n# With our ETF weights built, let's compare it to the index. Run the next cell to calculate the ETF returns and compare it to the index returns.\n\n# In[21]:\n\n\noptim_etf_returns = generate_weighted_returns(returns, optimal_single_rebalance_etf_weights)\noptim_etf_cumulative_returns = calculate_cumulative_returns(optim_etf_returns)\nproject_helper.plot_benchmark_returns(index_weighted_cumulative_returns, optim_etf_cumulative_returns, 'Optimized ETF vs Index')\n\noptim_etf_tracking_error = tracking_error(np.sum(index_weighted_returns, 1), np.sum(optim_etf_returns, 1))\nprint('Optimized ETF Tracking Error: {}'.format(optim_etf_tracking_error))\n\n\n# ## Rebalance Portfolio Over Time\n# The single optimized ETF portfolio used the same weights for the entire history. This might not be the optimal weights for the entire period. Let's rebalance the portfolio over the same period instead of using the same weights. Implement `rebalance_portfolio` to rebalance a portfolio.\n# \n# Reblance the portfolio every n number of days, which is given as `shift_size`. When rebalancing, you should look back a certain number of days of data in the past, denoted as `chunk_size`. Using this data, compute the optoimal weights using `get_optimal_weights` and `get_covariance_returns`.\n\n# In[22]:\n\n\ndef rebalance_portfolio(returns, index_weights, shift_size, chunk_size):\n    \"\"\"\n    Get weights for each rebalancing of the portfolio.\n\n    Parameters\n    ----------\n    returns : DataFrame\n        Returns for each ticker and date\n    index_weights : DataFrame\n        Index weight for each ticker and date\n    shift_size : int\n        The number of days between each rebalance\n    chunk_size : int\n        The number of days to look in the past for rebalancing\n\n    Returns\n    -------\n    all_rebalance_weights  : list of Ndarrays\n        The ETF weights for each point they are rebalanced\n    \"\"\"\n    returns = returns.fillna(0).copy()\n    \n    generate=np.arange(1,len(returns))\n    \n    lists_i=[]\n    \n    count=0\n    \n    lists_r=[]\n    \n    count=-1\n    for i in generate:\n        count+=1\n        if len(lists_r)!=chunk_size:\n            lists_r.append(count)\n            \n        if len(lists_r)==chunk_size:\n            n = lists_r[shift_size-chunk_size:]\n            count=n[-1]\n            lists_i.append(lists_r)\n            lists_r = []\n            for i in n:\n                lists_r.append(i)\n    lists_d=[]\n    \n    for d in lists_i :\n        lists_d.append(d[-1])\n        \n    list_vals=[]\n    for i in lists_i:\n        list_input=[]\n        for n in i:\n            list_input.append(returns.iloc[n].values)\n            \n        list_vals.append(list_input)\n        list_input=[]\n    \n    v=np.array(list_vals)\n    \n    rest = []\n    for i in v:\n        k= pd.DataFrame(i)\n        rest.append(get_covariance_returns(k))\n    \n    weights = []\n    \n    for (i,n) in zip(lists_d,rest):\n        index_w = index_weights.iloc[i]\n        weights.append(get_optimal_weights(n,index_w,scale=2.0))\n        \n    \n    \n    assert returns.index.equals(index_weights.index)\n    assert returns.columns.equals(index_weights.columns)\n    assert shift_size > 0\n    assert chunk_size >= 0\n    \n    #TODO: Implement function\n    \n    \n    \n    return weights\n\nproject_tests.test_rebalance_portfolio(rebalance_portfolio)\n\n\n# Run the following cell to rebalance the portfolio using `rebalance_portfolio`.\n\n# In[23]:\n\n\nchunk_size = 250\nshift_size = 5\nall_rebalance_weights = rebalance_portfolio(returns, index_weights, shift_size, chunk_size)\n\n\n# ## Portfolio Turnover\n# With the portfolio rebalanced, we need to use a metric to measure the cost of rebalancing the portfolio. Implement `get_portfolio_turnover` to calculate the annual portfolio turnover. We'll be using the formulas used in the classroom:\n# \n# $ AnnualizedTurnover =\\frac{SumTotalTurnover}{NumberOfRebalanceEvents} * NumberofRebalanceEventsPerYear $\n# \n# $ SumTotalTurnover =\\sum_{t,n}{\\left | x_{t,n} - x_{t+1,n} \\right |} $ Where $ x_{t,n} $ are the weights at time $ t $ for equity $ n $.\n# \n# $ SumTotalTurnover $ is just a different way of writing $ \\sum \\left | x_{t_1,n} - x_{t_2,n} \\right | $\n\n# In[40]:\n\n\ndef get_portfolio_turnover(all_rebalance_weights, shift_size, rebalance_count, n_trading_days_in_year=252):\n    \"\"\"\n    Calculage portfolio turnover.\n\n    Parameters\n    ----------\n    all_rebalance_weights : list of Ndarrays\n        The ETF weights for each point they are rebalanced\n    shift_size : int\n        The number of days between each rebalance\n    rebalance_count : int\n        Number of times the portfolio was rebalanced\n    n_trading_days_in_year: int\n        Number of trading days in a year\n    \n    Returns\n    -------\n    portfolio_turnover  : float\n        The portfolio turnover\n    \"\"\"\n    rebalance_e = n_trading_days_in_year/shift_size\n    \n    df = pd.DataFrame(all_rebalance_weights)\n    df_s=df.diff(periods=-1)\n    df_t=df_s.fillna(0)\n\n    turnover_per_n = df_t.apply( lambda x: abs(x)).sum()\n    \n    sum_total_turnover = turnover_per_n.sum()\n    \n    annualized_turnover = (sum_total_turnover*rebalance_e)/rebalance_count\n    \n    assert shift_size > 0\n    assert rebalance_count > 0\n    \n    #TODO: Implement function\n    \n    return annualized_turnover\n\nproject_tests.test_get_portfolio_turnover(get_portfolio_turnover)\n\n\n# Run the following cell to get the portfolio turnover from  `get_portfolio turnover`.\n\n# In[41]:\n\n\nprint(get_portfolio_turnover(all_rebalance_weights, shift_size, len(all_rebalance_weights) - 1))\n\n\n# That's it! You've built a smart beta portfolio in part 1 and did portfolio optimization in part 2. You can now submit your project.\n\n# ## Submission\n# Now that you're done with the project, it's time to submit it. Click the submit button in the bottom right. One of our reviewers will give you feedback on your project with a pass or not passed grade. You can continue to the next section while you wait for feedback.\n", "meta": {"hexsha": "7c1021d9611709a82fad37e5434ba93c6605f7c6", "size": 29899, "ext": "py", "lang": "Python", "max_stars_repo_path": "project_3_starter.py", "max_stars_repo_name": "nsushant/AI-For-Trading", "max_stars_repo_head_hexsha": "f33598ec216e33bd441325f777a48efc3fcd202e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "project_3_starter.py", "max_issues_repo_name": "nsushant/AI-For-Trading", "max_issues_repo_head_hexsha": "f33598ec216e33bd441325f777a48efc3fcd202e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "project_3_starter.py", "max_forks_repo_name": "nsushant/AI-For-Trading", "max_forks_repo_head_hexsha": "f33598ec216e33bd441325f777a48efc3fcd202e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.7795071336, "max_line_length": 974, "alphanum_fraction": 0.7117629352, "include": true, "reason": "import numpy,import cvxpy", "num_tokens": 7015, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4416730056646256, "lm_q2_score": 0.13846179234652575, "lm_q1q2_score": 0.06115483599540128}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # K-mer \n# Basic K-mer counting.\n\n# In[1]:\n\n\nimport time\ndef show_time():\n    t = time.time()\n    print(time.strftime('%Y-%m-%d %H:%M:%S %Z', time.localtime(t)))\nshow_time()\n\n\n# In[2]:\n\n\nPC_SEQUENCES=32000\nNC_SEQUENCES=32000\nRNA_LEN=32\nCDS_LEN=16\n\n\n# In[3]:\n\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\n\n# In[4]:\n\n\nimport sys\nIN_COLAB = False\ntry:\n    from google.colab import drive\n    IN_COLAB = True\nexcept:\n    pass\nif IN_COLAB:\n    print(\"On Google CoLab, mount cloud-local file, get our code from GitHub.\")\n    PATH='/content/drive/'\n    #drive.mount(PATH,force_remount=True)  # hardly ever need this\n    #drive.mount(PATH)    # Google will require login credentials\n    DATAPATH=PATH+'My Drive/data/'  # must end in \"/\"\n    import requests\n    r = requests.get('https://raw.githubusercontent.com/ShepherdCode/Soars2021/master/SimTools/RNA_describe.py')\n    with open('RNA_describe.py', 'w') as f:\n        f.write(r.text)  \n    from RNA_describe import Random_Base_Oracle\nelse:\n        print(\"CoLab not working. On my PC, use relative paths.\")\n        DATAPATH='data/'  # must end in \"/\"\n        sys.path.append(\"..\") # append parent dir in order to use sibling dirs\n        from SimTools.RNA_describe import Random_Base_Oracle\nMODELPATH=\"BestModel\"  # saved on cloud instance and lost after logout\n#MODELPATH=DATAPATH+MODELPATH  # saved on Google Drive but requires login\n\n\n# ## K-mer counting\n\n# ### Functions to create the dict of {kmer:count}\n\n# In[5]:\n\n\ndef make_kmer_keys(K):\n    shorter_kmers=['']\n    for i in range(K):\n        longer_kmers=[]\n        for mer in shorter_kmers:\n            # No support for N or any non-ACGT bases.\n            longer_kmers.append(mer+'A')\n            longer_kmers.append(mer+'C')\n            longer_kmers.append(mer+'G')\n            longer_kmers.append(mer+'T')\n        shorter_kmers = longer_kmers\n    return shorter_kmers\ndef make_kmer_dict(keys,init=0):\n    return dict.fromkeys(keys,init)\ndef make_dict_upto_K(max_K):\n    keys=make_kmer_keys(1)\n    for k in range(2,max_K+1):\n        keys.extend(make_kmer_keys(k))\n    counts = make_kmer_dict(keys)\n    return counts\n\n\n# ### Naive K-mer counting algorithm\n# Algorithm:  \n# 1. for every string  \n#     1. for every K  \n#         1. for every position  \n#             1. kmer=substring\n#             2. count{kmer}++\n\n# In[6]:\n\n\ndef update_count_one_K(counts,K,rna,tail=False):\n    L = len(rna)\n    padding=\" \"*(K-1)\n    padded=rna+padding\n    for i in range(0,L-K+1):\n        kmer=padded[i:i+K]\n        counts[kmer] += 1\n    if tail and K>1:  \n        # for Harvester algorithm, count last letters as special case\n        for start_pos in range(L-K+1,L):\n            for end_pos in range(start_pos+1,L+1):\n                kmer=rna[start_pos:end_pos]\n                counts[kmer] += 1\n    return counts\ndef update_count_upto_K(counts,max_K,sample,tail=False):\n    for i in range(1,max_K+1):\n        update_count_one_K(counts,i,sample,tail)\n    return counts\n\n\n# ### Harvester K-mer counting algorithm\n# Algorithm:  \n# 1. Count K-mers for max K only  \n# 2. For each K-mer in counts table:  \n#     1. For every prefix of the K-mer:  \n#         1. count{prefix} += count{kmer}  \n# 3. Handle last K-1 letters of each string as special case\n\n# In[7]:\n\n\ndef harvest_counts_from_K(counts,max_K):\n    for kmer in counts.keys():\n        klen = len(kmer)\n        kcnt = counts[kmer]\n        if klen==max_K and kcnt>0:\n            for i in range(1,klen):\n                prefix = kmer[:i]\n                counts[prefix] += kcnt\n    return counts\n\n\n# In[8]:\n\n\ndef count_to_frequency(counts,max_K):\n    freqs = dict.fromkeys(counts.keys(),0.0)\n    for k in range(1,max_K+1):\n        tot = 0\n        for kmer in counts.keys():\n            if len(kmer)==k:\n                tot += counts[kmer]\n        for kmer in counts.keys():\n            if len(kmer)==k:\n                freqs[kmer] = 1.0*counts[kmer]/tot\n    return freqs\n\n\n# ## Demo\n\n# ### Demo: Naive algorithm\n\n# In[9]:\n\n\nMAX_K = 3\ncounts1 = make_dict_upto_K(MAX_K)\nprint(\"Initial counts:\\n\",counts1)\n\nsample = \"ACCGGGTTTTACGTACGT\"\nupdate_count_upto_K(counts1,MAX_K,sample)\nprint(\"Final counts:\\n\",counts1)\n\n\n# ### Demo: Harvester algorithm\n\n# In[10]:\n\n\nMAX_K = 3\ncounts2 = make_dict_upto_K(MAX_K)\nprint(\"Initial counts:\\n\",counts2)\n\nsample = \"ACCGGGTTTTACGTACGT\"\nupdate_count_one_K(counts2,MAX_K,sample,True)\nprint(\"Partial counts (just max K and special case letters)\\n:\",counts2)\nharvest_counts_from_K(counts2,MAX_K)\nprint(\"Final counts (includes smaller values of K):\\n\",counts2)\n\n\n# In[11]:\n\n\nif counts1==counts2:\n    print(\"Success. Harvester output matches naive results!\")\nelse:\n    print(\"Fail. Harvester output differs from naive results!\")\n\n\n# In[12]:\n\n\nfreqs = count_to_frequency(counts2,MAX_K)\nprint (\"Frequency:\\n\",freqs)\n\n\n# ## Demo on large dataset\n\n# In[13]:\n\n\nrbo=Random_Base_Oracle(RNA_LEN,True)\npc_all,nc_all = rbo.get_partitioned_sequences(CDS_LEN,10) # just testing\npc_all,nc_all = rbo.get_partitioned_sequences(CDS_LEN,PC_SEQUENCES)\nprint(\"Use\",len(pc_all),\"PC seqs\")\nprint(\"Use\",len(nc_all),\"NC seqs\")\n\n\n# In[14]:\n\n\nMAX_K = 3\npc_counts = make_dict_upto_K(MAX_K)\nfor sample in pc_all:\n    update_count_one_K(pc_counts,MAX_K,sample,True)\nharvest_counts_from_K(pc_counts,MAX_K)\nprint(\"PC counts:\\n\",pc_counts)\npc_freqs = count_to_frequency(pc_counts,MAX_K)\nprint (\"Frequency:\\n\",pc_freqs)\n\n\n# In[15]:\n\n\nnc_counts = make_dict_upto_K(MAX_K)\nfor sample in nc_all:\n    update_count_one_K(nc_counts,MAX_K,sample,True)\nharvest_counts_from_K(nc_counts,MAX_K)\nprint(\"NC counts:\\n\",nc_counts)\nnc_freqs = count_to_frequency(nc_counts,MAX_K)\nprint (\"Frequency:\\n\",nc_freqs)\n\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "5277142f08d540eed3e12494fb70a089185dbf1b", "size": 5710, "ext": "py", "lang": "Python", "max_stars_repo_path": "Scripts/Kmer_100.py", "max_stars_repo_name": "ShepherdCode/Soars2021", "max_stars_repo_head_hexsha": "ab4f304eaa09e52d260152397a6c53d7a05457da", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-16T14:49:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-16T14:49:04.000Z", "max_issues_repo_path": "Scripts/Kmer_100.py", "max_issues_repo_name": "ShepherdCode/Soars2021", "max_issues_repo_head_hexsha": "ab4f304eaa09e52d260152397a6c53d7a05457da", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Scripts/Kmer_100.py", "max_forks_repo_name": "ShepherdCode/Soars2021", "max_forks_repo_head_hexsha": "ab4f304eaa09e52d260152397a6c53d7a05457da", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.6587301587, "max_line_length": 112, "alphanum_fraction": 0.6570928196, "include": true, "reason": "import numpy", "num_tokens": 1663, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4571367316191467, "lm_q2_score": 0.13296424535145931, "lm_q1q2_score": 0.06078284054217243}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# ## Rover Lab Notebook\n# This notebook contains the functions from the lesson and provides the scaffolding you need to test out your mapping methods.  The steps you need to complete in this notebook for the project are the following:\n# \n# * First just run each of the cells in the notebook, examine the code and the results of each.\n# \n# **Note: For the online lab, data has been collected and provided for you. If you would like to try locally please do so! Please continue instructions from the continue point.**\n# * Run the simulator in \"Training Mode\" and record some data. Note: the simulator may crash if you try to record a large (longer than a few minutes) dataset, but you don't need a ton of data, just some example images to work with.   \n# * Change the data directory path (2 cells below) to be the directory where you saved data\n# * Test out the functions provided on your data\n# \n# **Continue Point**\n# * Write new functions (or modify existing ones) to report and map out detections of obstacles and rock samples (yellow rocks)\n# * Populate the `process_image()` function with the appropriate steps/functions to go from a raw image to a worldmap.\n# * Run the cell that calls `process_image()` using `moviepy` functions to create video output\n# * Once you have mapping working, move on to modifying `perception.py` and `decision.py` in the project to allow your rover to navigate and map in autonomous mode!\n# \n# **Note: If, at any point, you encounter frozen display windows or other confounding issues, you can always start again with a clean slate by going to the \"Kernel\" menu above and selecting \"Restart & Clear Output\".**\n# \n# **Run the next cell to get code highlighting in the markdown cells.**\n\n# In[31]:\n\n\nget_ipython().run_cell_magic('HTML', '', '<style> code {background-color : orange !important;} </style>')\n\n\n# In[32]:\n\n\nget_ipython().run_line_magic('matplotlib', 'inline')\n#%matplotlib qt # Choose %matplotlib qt to plot to an interactive window (note it may show up behind your browser)\n# Make some of the relevant imports\nimport cv2 # OpenCV for perspective transform\nimport numpy as np\nimport matplotlib.image as mpimg\nimport matplotlib.pyplot as plt\nimport scipy.misc # For saving images as needed\nimport glob  # For reading in a list of images from a folder\n\n\n# ## Quick Look at the Data\n# There's some example data provided in the `test_dataset` folder.  This basic dataset is enough to get you up and running but if you want to hone your methods more carefully you should record some data of your own to sample various scenarios in the simulator.  \n# \n# Next, read in and display a random image from the `test_dataset` folder\n\n# In[33]:\n\n\npath = './test_dataset/IMG/*'\nimg_list = glob.glob(path)\n# Grab a random image and display it\nidx = np.random.randint(0, len(img_list)-1)\nimage = mpimg.imread(img_list[idx])\nplt.imshow(image)\n\n\n# ## Calibration Data\n# Read in and display example grid and rock sample calibration images.  You'll use the grid for perspective transform and the rock image for creating a new color selection that identifies these samples of interest. \n\n# In[34]:\n\n\n# In the simulator you can toggle on a grid on the ground for calibration\n# You can also toggle on the rock samples with the 0 (zero) key.  \n# Here's an example of the grid and one of the rocks\nexample_grid = './calibration_images/example_grid1.jpg'\nexample_rock = './calibration_images/example_rock1.jpg'\ngrid_img = mpimg.imread(example_grid)\nrock_img = mpimg.imread(example_rock)\n\nfig = plt.figure(figsize=(12,3))\nplt.subplot(121)\nplt.imshow(grid_img)\nplt.subplot(122)\nplt.imshow(rock_img)\n\n\n# ## Perspective Transform\n# \n# Define the perspective transform function from the lesson and test it on an image.\n\n# In[35]:\n\n\n# Define a function to perform a perspective transform\n# I've used the example grid image above to choose source points for the\n# grid cell in front of the rover (each grid cell is 1 square meter in the sim)\n# Define a function to perform a perspective transform\ndef perspect_transform(img, src, dst):           \n    M = cv2.getPerspectiveTransform(src, dst)\n    warped = cv2.warpPerspective(img, M, (img.shape[1], img.shape[0]))# keep same size as input image\n    mask = cv2.warpPerspective(np.ones_like(img[:,:,0]), M, (img.shape[1], img.shape[0]))\n    return warped, mask\n\n# Define calibration box in source (actual) and destination (desired) coordinates\n# These source and destination points are defined to warp the image\n# to a grid where each 10x10 pixel square represents 1 square meter\n# The destination box will be 2*dst_size on each side\ndst_size = 5 \n# Set a bottom offset to account for the fact that the bottom of the image \n# is not the position of the rover but a bit in front of it\n# this is just a rough guess, feel free to change it!\nbottom_offset = 6\nsource = np.float32([[14, 140], [301 ,140],[200, 96], [118, 96]])\ndestination = np.float32([[image.shape[1]/2 - dst_size, image.shape[0] - bottom_offset],\n                  [image.shape[1]/2 + dst_size, image.shape[0] - bottom_offset],\n                  [image.shape[1]/2 + dst_size, image.shape[0] - 2*dst_size - bottom_offset], \n                  [image.shape[1]/2 - dst_size, image.shape[0] - 2*dst_size - bottom_offset],\n                  ])\nwarped, mask = perspect_transform(image, source, destination)\nfig = plt.figure(figsize=(12,3))\nplt.subplot(121)\nplt.imshow(warped)\nplt.subplot(122)\nplt.imshow(mask)\n#scipy.misc.imsave('../output/warped_example.jpg', warped)\n\n\n# ## Color Thresholding\n# Define the color thresholding function from the lesson and apply it to the warped image\n# \n# **TODO:** Ultimately, you want your map to not just include navigable terrain but also obstacles and the positions of the rock samples you're searching for.  Modify this function or write a new function that returns the pixel locations of obstacles (areas below the threshold) and rock samples (yellow rocks in calibration images), such that you can map these areas into world coordinates as well.  \n# **Suggestion:** Think about imposing a lower and upper boundary in your color selection to be more specific about choosing colors.  Feel free to get creative and even bring in functions from other libraries.  Here's an example of [color selection](http://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_colorspaces/py_colorspaces.html) using OpenCV.  \n# **Beware:** if you start manipulating images with OpenCV, keep in mind that it defaults to `BGR` instead of `RGB` color space when reading/writing images, so things can get confusing.\n\n# In[36]:\n\n\n# Identify pixels above the threshold\n# Threshold of RGB > 160 does a nice job of identifying ground pixels only\ndef color_thresh(img, rgb_thresh=(160, 160, 160)):\n    # Create an array of zeros same xy size as img, but single channel\n    color_select = np.zeros_like(img[:,:,0])\n    # Require that each pixel be above all three threshold values in RGB\n    # above_thresh will now contain a boolean array with \"True\"\n    # where threshold was met\n    above_thresh = (img[:,:,0] > rgb_thresh[0])                 & (img[:,:,1] > rgb_thresh[1])                 & (img[:,:,2] > rgb_thresh[2])\n    # Index the array of zeros with the boolean array and set to 1\n    color_select[above_thresh] = 1\n   \n    # Return the binary image\n    return color_select\n\ndef yellow_rock_thresh(img):\n    # identify if the image has a rock in it \n    # define a threshold for the rock object\n    color_select_yellow = np.zeros_like(img[:,:,0])\n    yellow_thresh = (img[:,:,0] > 50) & (img[:,:,0] < 258)                  & (img[:,:,1] > 115) & (img[:,:,1] < 256)                  & (img[:,:,2] > -1) &  (img[:,:,2] < 100)\n            \n    color_select_yellow[yellow_thresh] = 1\n    \n    is_yellow_rock = False\n    for nested_list in color_select_yellow:\n        for item in nested_list:\n            if item:\n                is_yellow_rock = True\n                break\n    return color_select_yellow, is_yellow_rock\n    \n\n\n\nthreshed = color_thresh(warped)\nyellow_rock_img, is_yellow_rock = yellow_rock_thresh(warped)\nfig = plt.figure(figsize=(12,3))\nplt.subplot(121)\nplt.imshow(threshed, cmap='gray')\nplt.subplot(122)\nplt.imshow(yellow_rock_img, cmap='gray')\nprint (is_yellow_rock)\n#scipy.misc.imsave('../output/warped_threshed.jpg', threshed*255)\n\n\n# ## Coordinate Transformations\n# Define the functions used to do coordinate transforms and apply them to an image.\n\n# In[37]:\n\n\ndef rover_coords(binary_img):\n    # Identify nonzero pixels\n    ypos, xpos = binary_img.nonzero()\n    # Calculate pixel positions with reference to the rover position being at the \n    # center bottom of the image.  \n    x_pixel = np.absolute(ypos - binary_img.shape[0]).astype(np.float)\n    y_pixel = -(xpos - binary_img.shape[0]).astype(np.float)\n    return x_pixel, y_pixel\n\n# Define a function to convert to radial coords in rover space\ndef to_polar_coords(x_pixel, y_pixel):\n    # Convert (x_pixel, y_pixel) to (distance, angle) \n    # in polar coordinates in rover space\n    # Calculate distance to each pixel\n    dist = np.sqrt(x_pixel**2 + y_pixel**2)\n    # Calculate angle away from vertical for each pixel\n    angles = np.arctan2(y_pixel, x_pixel)\n    return dist, angles\n\n# Define a function to apply a rotation to pixel positions\ndef rotate_pix(xpix, ypix, yaw):\n    # TODO:\n    # Convert yaw to radians\n    yaw_rad = yaw * np.pi / 180\n    \n    # Apply a rotation\n    x_rotated = xpix * np.cos(yaw_rad) - ypix * np.sin(yaw_rad)\n    y_rotated = xpix * np.sin(yaw_rad) + ypix * np.cos(yaw_rad)\n    # Return the result  \n    return x_rotated, y_rotated\n\n\n# Define a function to perform a translation\ndef translate_pix(xpix_rot, ypix_rot, xpos, ypos, scale): \n    # TODO:\n    # Apply a scaling and a translation\n    # Assume a scale factor of 10 between world space pixels and rover space pixels\n    # Perform translation and convert to integer since pixel values can't be float\n    x_world = np.int_(xpos + (xpix_rot / scale))\n    y_world = np.int_(ypos + (ypix_rot / scale))\n    \n    # Return the result  \n    return x_world, y_world\n\n\n# Define a function to apply rotation and translation (and clipping)\n# Once you define the two functions above this function should work\ndef pix_to_world(xpix, ypix, xpos, ypos, yaw, world_size, scale):\n    # Apply rotation\n    xpix_rot, ypix_rot = rotate_pix(xpix, ypix, yaw)\n    # Apply translation\n    xpix_tran, ypix_tran = translate_pix(xpix_rot, ypix_rot, xpos, ypos, scale)\n    # Perform rotation, translation and clipping all at once\n    x_pix_world = np.clip(np.int_(xpix_tran), 0, world_size - 1)\n    y_pix_world = np.clip(np.int_(ypix_tran), 0, world_size - 1)\n    # Return the result\n    return x_pix_world, y_pix_world\n\n# Grab another random image\nidx = np.random.randint(0, len(img_list)-1)\n#image = mpimg.imread(img_list[idx])\nimage = rock_img\nwarped, mask = perspect_transform(image, source, destination)\nthreshed = color_thresh(warped)  # navigable terrain pixels\nobs_map = np.absolute(np.float32(threshed)-1)*mask  #obstacles pixels\n\n# Calculate pixel values in rover-centric coords and distance/angle to all pixels\nxpix, ypix = rover_coords(threshed)\ndist, angles = to_polar_coords(xpix, ypix)\nmean_dir = np.mean(angles)\n\n# Do some plotting\nfig = plt.figure(figsize=(12,9))\nplt.subplot(221)\nplt.imshow(image)\nplt.subplot(222)\nplt.imshow(warped)\nplt.subplot(223)\nplt.imshow(threshed, cmap='gray')\nplt.subplot(224)\nplt.plot(xpix, ypix, '.')\nplt.ylim(-160, 160)\nplt.xlim(0, 160)\narrow_length = 100\nx_arrow = arrow_length * np.cos(mean_dir)\ny_arrow = arrow_length * np.sin(mean_dir)\nplt.arrow(0, 0, x_arrow, y_arrow, color='red', zorder=2, head_width=10, width=2)\n\n\n# ## Read in saved data and ground truth map of the world\n# The next cell is all setup to read your saved data into a `pandas` dataframe.  Here you'll also read in a \"ground truth\" map of the world, where white pixels (pixel value = 1) represent navigable terrain.  \n# \n# After that, we'll define a class to store telemetry data and pathnames to images.  When you instantiate this class (`data = Databucket()`) you'll have a global variable called `data` that you can refer to for telemetry and map data within the `process_image()` function in the following cell.  \n# \n\n# In[38]:\n\n\n# Import pandas and read in csv file as a dataframe\nimport pandas as pd\n# Change this path to your data directory\ndf = pd.read_csv('./test_dataset/robot_log.csv')\ncsv_img_list = df[\"Path\"].tolist() # Create list of image pathnames\n# Read in ground truth map and create a 3-channel image with it\nground_truth = mpimg.imread('./calibration_images/map_bw.png')\nground_truth_3d = np.dstack((ground_truth*0, ground_truth*255, ground_truth*0)).astype(np.float)\n\n# Creating a class to be the data container\n# Will read in saved data from csv file and populate this object\n# Worldmap is instantiated as 200 x 200 grids corresponding \n# to a 200m x 200m space (same size as the ground truth map: 200 x 200 pixels)\n# This encompasses the full range of output position values in x and y from the sim\nclass Databucket():\n    def __init__(self):\n        self.images = csv_img_list  \n        self.xpos = df[\"X_Position\"].values\n        self.ypos = df[\"Y_Position\"].values\n        self.yaw = df[\"Yaw\"].values\n        self.count = -1 # This will be a running index, setting to -1 is a hack\n                        # because moviepy (below) seems to run one extra iteration\n        self.worldmap = np.zeros((200, 200, 3)).astype(np.float)\n        self.ground_truth = ground_truth_3d # Ground truth worldmap\n\n# Instantiate a Databucket().. this will be a global variable/object\n# that you can refer to in the process_image() function below\ndata = Databucket()\n\n\n# ## Write a function to process stored images\n# \n# Modify the `process_image()` function below by adding in the perception step processes (functions defined above) to perform image analysis and mapping.  The following cell is all set up to use this `process_image()` function in conjunction with the `moviepy` video processing package to create a video from the images you saved taking data in the simulator.  \n# \n# In short, you will be passing individual images into `process_image()` and building up an image called `output_image` that will be stored as one frame of video.  You can make a mosaic of the various steps of your analysis process and add text as you like (example provided below).  \n# \n# \n# \n# To start with, you can simply run the next three cells to see what happens, but then go ahead and modify them such that the output video demonstrates your mapping process.  Feel free to get creative!\n\n# In[43]:\n\n\n\n# Define a function to pass stored images to\n# reading rover position and yaw angle from csv file\n# This function will be used by moviepy to create an output video\ndef process_image(img):\n    # Example of how to use the Databucket() object defined above\n    # to print the current x, y and yaw values \n    # print(data.xpos[data.count], data.ypos[data.count], data.yaw[data.count])\n\n    # TODO: \n    # 1) Define source and destination points for perspective transform\n    source = np.float32([\n                [14, 140], [301, 140], # bottom left to right\n                [200, 96], [118, 96]]) # top rigt to left             \n    dst_size = 5 \n    bottom_offset = 6\n    destination = np.float32([[image.shape[1]/2 - dst_size, image.shape[0] - bottom_offset],\n                  [image.shape[1]/2 + dst_size, image.shape[0] - bottom_offset],\n                  [image.shape[1]/2 + dst_size, image.shape[0] - 2*dst_size - bottom_offset], \n                  [image.shape[1]/2 - dst_size, image.shape[0] - 2*dst_size - bottom_offset],\n                  ])\n    \n    # 2) Apply perspective transform\n    warped, mask = perspect_transform(img, source, destination)\n    # 3) Apply color threshold to identify navigable terrain/obstacles/rock samples\n    \n    # def color_thresh\n    threshed = color_thresh(warped) # navigable pixels\n    yellow_rock_threshed, is_yellow_rock = yellow_rock_thresh(warped)  # rock pixels\n    obs_map = np.absolute(np.float32(threshed)-1)*mask  #obstacles pixels\n    \n    # 4) Convert thresholded image pixel values to rover-centric coords\n    xpix, ypix = rover_coords(threshed)\n    xpix_obs, ypix_obs = rover_coords(obs_map)\n    \n    # 5) Convert rover-centric pixel values to world coords\n    scale = 10\n    x_world, y_world = pix_to_world(xpix, ypix, data.xpos[data.count], data.ypos[data.count], \\\n        data.yaw[data.count], data.worldmap.shape[0], scale)\n    x_obs, y_obs = pix_to_world(xpix_obs, ypix_obs, data.xpos[data.count], \\\n        data.ypos[data.count], data.yaw[data.count], data.worldmap.shape[0], scale)\n\n    # 6) Update worldmap (to be displayed on right side of screen)\n        # Example: data.worldmap[obstacle_y_world, obstacle_x_world, 0] += 1\n        #          data.worldmap[rock_y_world, rock_x_world, 1] += 1\n        #          data.worldmap[navigable_y_world, navigable_x_world, 2] += 1\n    data.worldmap[y_world, x_world, 2] += 255  # blue nav terrain\n    data.worldmap[y_obs, x_obs, 0] += 255 # red obstacles\n    nav_pix = data.worldmap[:,:,2] > 0\n    data.worldmap[nav_pix, 0] = 0\n    \n    if is_yellow_rock:\n        xpix_rock, ypix_rock = rover_coords(yellow_rock_threshed)\n        x_world_rock, y_world_rock = pix_to_world(xpix_rock, ypix_rock, data.xpos[data.count], \\\n            data.ypos[data.count], data.yaw[data.count], data.worldmap.shape[0], scale)\n        data.worldmap[y_world_rock, x_world_rock, :] = 255\n    \n    # 7) Make a mosaic image, below is some example code\n        # First create a blank image (can be whatever shape you like)\n    output_image = np.zeros((img.shape[0] + data.worldmap.shape[0], img.shape[1]*2, 3))\n        # Next you can populate regions of the image with various output\n        # Here I'm putting the original image in the upper left hand corner\n    #left corner\n    output_image[0:img.shape[0], 0:img.shape[1]] = img\n    \n    # first a warped image\n    # upper right \n    output_image[0:img.shape[0], img.shape[1]:] = warped\n\n    # Overlay worldmap with ground truth map\n    map_add = cv2.addWeighted(data.worldmap, 1, data.ground_truth, 0.5, 0)\n        # Flip map overlay so y-axis points upward and add to output_image \n    #lower left \n    output_image[img.shape[0]:, 0:data.worldmap.shape[1]] = np.flipud(map_add)\n    #lower right ?????? \n    \n    \n        # Then putting some text over the image\n    if is_yellow_rock:    \n        cv2.putText(output_image,\"Rock Found!!!\", (20, 20), \n                cv2.FONT_HERSHEY_COMPLEX, 0.4, (255, 255, 255), 1)\n    else:\n         cv2.putText(output_image,\"No Rock\", (20, 20), \n                cv2.FONT_HERSHEY_COMPLEX, 0.4, (255, 255, 255), 1)\n    data.count += 1 # Keep track of the index in the Databucket()\n    \n    return output_image\n\n    \n\n\n# ## Make a video from processed image data\n# Use the [moviepy](https://zulko.github.io/moviepy/) library to process images and create a video.\n#   \n\n# In[44]:\n\n\n# Import everything needed to edit/save/watch video clips\nfrom moviepy.editor import VideoFileClip\nfrom moviepy.editor import ImageSequenceClip\n\n\n# Define pathname to save the output video\noutput = './output/test_mapping.mp4'\ndata = Databucket() # Re-initialize data in case you're running this cell multiple times\nclip = ImageSequenceClip(data.images, fps=60) # Note: output video will be sped up because \n                                          # recording rate in simulator is fps=25\nnew_clip = clip.fl_image(process_image) #NOTE: this function expects color images!!\nget_ipython().run_line_magic('time', 'new_clip.write_videofile(output, audio=False)')\n\n\n# ### This next cell should function as an inline video player\n# If this fails to render the video, try running the following cell (alternative video rendering method).  You can also simply have a look at the saved mp4 in your `/output` folder\n\n# In[45]:\n\n\noutput = './output/test_mapping.mp4'\nfrom IPython.display import HTML\nHTML(\"\"\"\n<video width=\"960\" height=\"540\" controls>\n  <source src=\"{0}\">\n</video>\n\"\"\".format(output))\n\n\n# In[ ]:\n\n\n\n\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "89ae0ef059c99676889f5abadae8f2ee880ff527", "size": 20128, "ext": "py", "lang": "Python", "max_stars_repo_path": "code/Rover_Lab_Notebook.py", "max_stars_repo_name": "VinoVino/RoboND-Rover-Project", "max_stars_repo_head_hexsha": "476722958b9bc12e91cf91974e5d7af1beb7e248", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "code/Rover_Lab_Notebook.py", "max_issues_repo_name": "VinoVino/RoboND-Rover-Project", "max_issues_repo_head_hexsha": "476722958b9bc12e91cf91974e5d7af1beb7e248", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/Rover_Lab_Notebook.py", "max_forks_repo_name": "VinoVino/RoboND-Rover-Project", "max_forks_repo_head_hexsha": "476722958b9bc12e91cf91974e5d7af1beb7e248", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.5670995671, "max_line_length": 401, "alphanum_fraction": 0.7062301272, "include": true, "reason": "import numpy,import scipy", "num_tokens": 5115, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43782349911420193, "lm_q2_score": 0.13846178879140303, "lm_q1q2_score": 0.06062182486226366}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     formats: ipynb,py:light\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.5'\n#       jupytext_version: 1.4.2\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# ## Import Main Librairies\n\n# +\n# Basic Python modules\nimport random\nimport csv\nimport pickle\nimport os\n\n# Scientific modules\nimport numpy as np\nimport scipy as scp\nimport matplotlib\nfrom matplotlib import pyplot as plt\n\nfrom scipy.io import loadmat\nimport networkx as nx\n\n# For better looking graphs\nimport seaborn as sns\nsns.set()\n\n# Just a custom color palette that I use\n# blue, darkblue, red, orange, green, palegreen, yellow, brokenwhite, brokengrey\ncolors = [\"#AF3127\",\"#6182B5\",\"#112A3C\",\"#D99C37\",\"#90A954\",\"#C5B868\",\"#FAC764\",\"#DAC0A6\",\"#C4C2D1\"]\nsns.set_palette(sns.color_palette(colors))\n# -\n\n# ## Configure paths for data once for all\n\n# +\n#generate_images = False\n\n#pickle_data_folder = 'new_new_pickle_data_cross/'\n\n# Folder in which data is placed\ndata_folder = '../fake_data'\n\n# Folder in which some computed objects will be saved\npickle_folder = 'cross_validation'\n\n# Control whether we recompute data even if it has been previously \n# computed and pickled\nrecompute_pickle = False\n\n# Suffix at the end of each .mat file; it is specified here in order to select \n# relevant files, as well as to make file name lighter during loading for \n# further operations (such as printing subjects names), since it does not carry \n# additional information.\nsuffix = '_fiber_number.mat'\n\n# For instance here, with those setting, every ../fake_data/*_fiber_number.mat \n# will be loaded\n\n# Keys used to split data between patients and controls. Subject whose filename \n# contains one of the control_keys will be affected to the control cohort, and \n# similarly for patients.\ncontrol_keys = ['060', 'dep', 'dpr', 'S', 'TI']\npatient_keys = ['lgp']\n\n# By default, the code expects a \"table.csv\" present in data_folder, containing \n# information about the patients, such as their age, the duration of the \n# disease, etc.\ncsv_path = data_folder + \"/table.csv\"\n\n\n# -\n\n# ## Load data\n\n# +\ndef get_matrix_file_list(data_folder, suffix):\n    \"\"\" \n        Return the list of files in the folder data_folder ending by suffix \n    \"\"\"\n    file_list = [f for f in os.listdir(data_folder) if f.endswith(suffix)]\n    return list(map(lambda x: data_folder + '/' + x, file_list))\n\ndef load_matrix_file(file):\n    \"\"\" \n        Return the matrix loaded from a Matlab data file. Note that the \n        'Measure' key is hardcoded, so you might need to adjust it to your own \n        data.\n    \"\"\"\n    return loadmat(file)['Measure']\n\n# Eventually create the folder in which data will be saved\nif not os.path.exists(pickle_folder):\n    os.mkdir(pickle_folder)\n\n# Create a dictionnary of all the matrices, where each matrix gets associated to \n# the filename of the corresponding .mat file minus the suffix.\nconnectivity_matrices = {}\n\nfor f in get_matrix_file_list(data_folder, suffix):\n    connectivity_matrices[f.replace(suffix,'').replace(data_folder + '/','')] = load_matrix_file(f)\n    \n# Create a dictionnary of metadata for each patient, obtained from the file \n# at csv_path (by default 'data_foler/table.csv')\npatient_info_dict = {}\n\nwith open(csv_path, 'r') as csv_file:\n    metadata = csv.DictReader(csv_file)\n    # Each patient is associated to a dictionnary containing all its information\n    for row in metadata:\n        metadata_dict = {key:row[key] for key in metadata.fieldnames if key != 'Subject'}\n        patient_info_dict[row['Subject']] = metadata_dict\n        \nprint(\"Succesfully loaded {} matrices from {}.\".format(len(connectivity_matrices), data_folder))\nprint(\"Metadata has been found in {} for {} subjects.\".format(csv_path,len(patient_info_dict)))\n# -\n\n# ## Split Data into Cohorts\n\n# +\n# list of controls and patients names\ncontrols = []\npatients = []\n\n# The following can be used to limit the number of either controls or patients \n# considered for the study if they are set to some non infinite number.\ncontrols_count = np.inf\npatients_count = np.inf\n\ncurrent_control = 0\ncurrent_patient = 0\n\nfor key in [*connectivity_matrices]:\n    # Use patients_keys and control_keys list to classify subject into cohorts\n    if any(list(map(lambda x: x in key, patient_keys))) and current_patient < patients_count:\n        patients.append(key)\n        current_patient += 1\n    elif any(list(map(lambda x: x in key, control_keys))) and current_control < controls_count:\n        controls.append(key)\n        current_control += 1\n    else:\n        print(\"Patient {} cannot be classified either as control or patient.\".format(key))\n\ncontrols_count = current_control\npatients_count = current_patient\n\nsubject_count = len(patients) + len(controls)\n\nprint(\"Classified {} controls and {} patients (total {} subjects)\".format(controls_count, patients_count, subject_count))\n\n\n# -\n\n# ## Basic network manipulation functions\n\n# +\ndef plot_connectivity_matrix(*matrix, save=None):\n    \"\"\"\n        Plot the connectivity matrix as a colormap\n        It uses a logarithmic scale for the colors and it is possible to plot \n        multiple matrices at once.\n    \"\"\"\n    \n    max_rows = 2\n    line = len(matrix) / 3 + 1\n    \n    for i, mat in enumerate(matrix):\n        plt.subplot(line, max_rows, i+1)\n        plt.imshow(np.log(mat+1),cmap='viridis')\n    \n    plt.tight_layout()\n    if save is None:\n        plt.show()\n    else:\n        plt.savefig(save,bbox_inches='tight')\n        \ndef get_network(matrix, threshold = 0):\n    \"\"\" \n        Return the network (as a networkx data structure) defined by matrix.\n        It is possible to specify a threshold that will disregard all the \n        edges below this threshold when creating the network\n    \"\"\"\n    G = nx.Graph()\n    N = matrix.shape[0]\n    G.add_nodes_from(list(range(N)))\n    G.add_weighted_edges_from([(i,j,1.0*matrix[i][j]) for i in range(0,N) for j in range(0,i) \\\n                                                                   if matrix[i][j] >= threshold])\n    return G\n\ndef filter_weights(matrix, ratio):\n    \"\"\"\n        Only keep a fraction of the weights of the matrix, fraction specified \n        via the threshold parameter\n    \"\"\"\n    n = matrix.shape[0]\n    filtered_matrix = np.zeros_like(matrix)\n    total_weight = np.sum(matrix)\n    weights_id = sorted([(matrix[i,j],i,j) for i in range(n-1) for j in range(i+1,n)], reverse=True)\n    \n    filtered_weight = 0\n    for (w,i,j) in weights_id:\n        filtered_weight += 2*w\n        \n        if filtered_weight > ratio*total_weight:\n            break\n        \n        filtered_matrix[i,j] = w\n        filtered_matrix[j,i] = w\n    \n    return filtered_matrix\n\n\n# -\n\n# ## Laplacian manipulation\n\n# +\ndef get_laplacian_matrix(matrix, threshold = 0):\n    \"\"\" \n        Return the laplacian matrix of the network defined by matrix.\n        It is possible to specify a threshold that will disregard all the \n        edges below this threshold when creating the network\n    \"\"\"\n    \n    L = np.zeros_like(matrix)\n    \n    assert(L.shape[0] == L.shape[1]), \"The network should be encoded by a square matrix\"\n    \n    N = L.shape[0]\n    \n    # Small one liner trick to get rid of the diagonal and apply the threshold.\n    A = np.multiply(np.where(matrix >= threshold, matrix , np.zeros_like(matrix)), np.ones((N,N)) - np.eye(N))\n    \n    # Use the definition of L as L = D - A \n    L = np.eye(N) * np.array([np.sum(A[i,:]) for i in range(N)]) - A\n    \n    return L\n\ndef get_stabilized_laplacian_matrix(matrix, threshold = 0, ratio=1.0, alpha = 1e-2):\n    \"\"\"\n        Prefered function to get the laplacian matrix of a network encoded by a \n        matrix. Can apply a ratio filtering of the weights of the matrix (i.e. \n        only keep ratio of the total weight) or / and apply a threshold. The \n        alpha parameter corrects a numerical issue.\n    \"\"\"\n    L = get_laplacian_matrix(filter_weights(matrix, ratio = ratio), threshold)\n    \n    n = L.shape[0]\n    \n    # Add a small epsilon to the diagonal of the Laplacian matrix. It should \n    # make the computation more stable. Idea from https://github.com/Hermina/GOT\n    \n    return L + alpha * np.eye(n)\n\n\n# -\n\n# Small tests to assess consistency of the different functions.\nassert np.allclose(nx.linalg.laplacian_matrix(get_network(connectivity_matrices[controls[0]])).toarray(), get_laplacian_matrix(connectivity_matrices[controls[0]])), \"Inconsistency in the Laplacian functions\"\nassert np.allclose(nx.linalg.laplacian_matrix(get_network(connectivity_matrices[patients[0]], threshold=10)).toarray(), get_stabilized_laplacian_matrix(connectivity_matrices[patients[0]], alpha=0, threshold=10)), \"Inconsistency in the Laplacian functions (test 2)\"\n\n# ## Wasserstein distance functions\n\n# +\n# Those are dictionaries used to speed up computations, by avoiding multiple \n# computations of the same objects.\nprecomp_dict_net = {}\nprecomp_dict_cov = {}\n\ndef wasserstein_networks(A, B, threshold = 0, threshold2 = None, ratio = 1.0):\n    \"\"\" \n            Returns the Wasserstein distance (in the sense of the GOT paper) \n            between the two networks encoded by A and B. It is possible to \n            apply a threshold to the network obtained via both matrices (and \n            even a different one per matrices)\n    \"\"\"\n    \n    if threshold2 is None:\n        threshold2 = threshold\n    \n    assert(A.shape == B.shape), \"compared networks should have the \\\n                                                        same number of nodes\"\n    \n    L1dag = None\n    L1dag_sqrt = None\n    L2dag = None\n    L2dag_sqrt = None\n    \n    if (A.tobytes(), threshold, ratio) not in precomp_dict_net:\n        L1 = get_stabilized_laplacian_matrix(A, threshold = threshold, ratio = ratio)\n        L1dag = np.real(scp.linalg.pinv(L1))\n        L1dag_sqrt = np.real(scp.linalg.sqrtm(L1dag))\n        \n        precomp_dict_net[(A.tobytes(), threshold,ratio)] = (L1dag, L1dag_sqrt)\n    else:\n        L1dag, L1dag_sqrt = precomp_dict_net[(A.tobytes(), threshold, ratio)]\n    \n    if (B.tobytes(), threshold2, ratio) not in precomp_dict_net:\n        L2 = get_stabilized_laplacian_matrix(B, threshold = threshold2, ratio = ratio)\n        L2dag = np.real(scp.linalg.pinv(L2))\n        L2dag_sqrt = np.real(scp.linalg.sqrtm(L2dag))\n        \n        precomp_dict_net[(B.tobytes(), threshold2, ratio)] = (L2dag, L2dag_sqrt)\n    \n    else :\n        L2dag, L2dag_sqrt = precomp_dict_net[(B.tobytes(), threshold2, ratio)]\n\n    W = np.trace(L1dag) + np.trace(L2dag) - 2*np.trace(np.real(scp.linalg.sqrtm(L1dag_sqrt @ L2dag @ L1dag_sqrt)))\n    \n    return W\n\n\ndef wasserstein_network_covariance(A, cov, threshold = 0, ratio = 1.0):\n    \"\"\" \n            Return the Wasserstein distance (in the sense of the GOT paper) \n            between the the network encoded by a matrix A, and the normal \n            distribution whose covariance matrix is given by cov. \n            It is possible to apply a threshold to the network obtained via \n            matrix A.\n    \"\"\"\n    \n    assert(A.shape == cov.shape), \"compared networks should have the \\\n                                                        same number of nodes\"\n    \n    N = A.shape[0]\n\n    L1dag = None\n    L1dag_sqrt = None\n    L2dag = None\n    L2dag_sqrt = None\n    \n    if (A.tobytes(), threshold, ratio) not in precomp_dict_net:\n        L1 = get_stabilized_laplacian_matrix(A, threshold = threshold, ratio = ratio)\n        L1dag = np.real(scp.linalg.pinv(L1))\n        L1dag_sqrt = np.real(scp.linalg.sqrtm(L1dag))\n        \n        precomp_dict_net[(A.tobytes(), threshold ,ratio)] = (L1dag, L1dag_sqrt)\n    else:\n        L1dag, L1dag_sqrt = precomp_dict_net[(A.tobytes(), threshold ,ratio)]\n    \n    if cov.tobytes() not in precomp_dict_cov:\n        L2dag = cov\n        L2dag_sqrt = np.real(scp.linalg.sqrtm(L2dag))\n        \n        precomp_dict_cov[cov.tobytes()] = L2dag_sqrt\n    \n    else:\n        L2dag = cov\n        L2dag_sqrt = precomp_dict_cov[cov.tobytes()]\n    \n    W = np.trace(L1dag) + np.trace(L2dag) - 2*np.trace(np.real(scp.linalg.sqrtm(L1dag_sqrt @ L2dag @ L1dag_sqrt)))\n    return W\n\ndef clip_remove(array, threshold):\n    \"\"\"\n        Small helper function to clip an array by removing values above a \n        certain threshold\n    \"\"\"\n    r = array[array < threshold]\n    print(\"Kept {} out of {} ({} %)\".format(r.shape[0], array.shape[0], r.shape[0]/array.shape[0] * 100))\n    return r\n\ndef barycenter_iteration(cov_list, iteration_count = 10):\n    \"\"\"\n        Return the covariance matrix of the barycenter of the distributions \n        whose covariances are given as cov_list ; iteration_count controls the\n        number of iteration made by the iterative algorithm.\n    \"\"\"\n    covariance_count = len(cov_list)\n\n    size = cov_list[0].shape[0]\n    curr_cov = np.eye(size)\n    \n    for iteration in range(iteration_count):\n        curr_cov_sqrt = np.real(scp.linalg.sqrtm(curr_cov))\n        curr_cov_pinv_sqrt = scp.linalg.pinv(curr_cov_sqrt)\n        big_sum = np.zeros_like(curr_cov)\n        for sigma in cov_list:\n            big_sum += 1/covariance_count * np.real(scp.linalg.sqrtm(curr_cov_sqrt @ sigma @ curr_cov_sqrt))\n        big_sum = big_sum @ big_sum\n        curr_cov = curr_cov_pinv_sqrt @ big_sum @ curr_cov_pinv_sqrt\n    \n    return curr_cov\n\n# Some functions to print a barycenter covariance as an approximate connectivity matrix\ndef cov_to_laplacian(cov, alpha = 1e-2):\n    n = cov.shape[0]\n    return scp.linalg.pinv(cov) - alpha * np.eye(n)\n\ndef laplacian_to_connectivity_matrix(laplacian):\n    n = laplacian.shape[0]\n    return np.multiply(laplacian, -(np.ones_like(laplacian) - 2*np.eye(n)))\n# -\n\n# ## Compute a distance matrix (distance subjects to controls)\n\n\n# ## Compute a barycenter with subsample of controls\n\n\ndef subsample_controls(controls, sample_size, ratio = 1.0):\n    \"\"\"\n        Return a random draw of sample_size controls, whose name are taken from \n        the controls array, as well as the covariance matrices of their \n        associated distribution. Ratio is used to control the sparsity of the \n        networks (see get_stabilized_laplacian_matrix for its exact effect)\n    \"\"\"\n    controls_count = len(controls)\n\n    random_controls_sample = random.sample(range(0, controls_count),sample_size)\n    controls_barycenter = np.array(controls)[random_controls_sample]\n\n    pseudo_inverses = [scp.linalg.pinv(get_stabilized_laplacian_matrix(connectivity_matrices[subject],ratio=ratio)) for subject in controls_barycenter]\n\n    return (controls_barycenter, pseudo_inverses)\n\n\ndef do_some_folds(fold_count = 50, control_sample_size = 10, ratios = [1.0]):\n    \"\"\"\n        Perform fold_count random folds. Each fold consists in: subsampling the \n        control group to randomly select control_sample_size controls, whose \n        barycenter is computed. Then all remaining controls + each patients are \n        compared to the barycenter. The results of multiple folds are aggregated \n        into distance_dict and distance_fold_count (the average distance for \n        subject s to the barycenters is thus \n        \n                        distance_dict[s] / distance_fold_count[s]\n        \n        ratios can be used to perform tests on multiple sparsity ratios at a \n        time \n    \"\"\"\n    for ratio in ratios:\n        true_folds = 0\n        print(\"Folding with sparsity ratio {:.2f}\".format(ratio))\n\n        pickle_file_path = pickle_folder + \"/dist_and_fold_count_r{:.2f}_k{}.pickle\".format(ratio, control_sample_size)\n        print(\"Will save or update {}\".format(pickle_file_path))\n\n        distance_dict = {s : 0.0 for s in patients + controls}\n        distance_fold_count = {s:0 for s in patients + controls}\n\n        for fold in range(fold_count):\n            if fold % 10 == 0: print(\"Fold {}\".format(fold))\n\n            controls_sample, pinvs = subsample_controls(controls, control_sample_size, ratio = ratio)\n\n            barycenter_cov = barycenter_iteration(pinvs)\n            \n            # list of all the other subjects (non sampled controls + patients)\n            subjects = patients + [c for c in controls if c not in controls_sample]\n            current_fold_distance_dict = {subject:wasserstein_network_covariance(connectivity_matrices[subject], barycenter_cov, ratio = ratio) for subject in subjects}\n\n            for subject, d in current_fold_distance_dict.items():\n                distance_fold_count[subject] += 1\n                distance_dict[subject] += d\n\n            true_folds += 1\n\n        # create or update the pickled data\n        if os.path.exists(pickle_file_path) and not recompute_pickle:\n            with open(pickle_file_path, 'rb') as filehandler:\n                loaded_dist_dict, loaded_dist_count, loaded_fold_count = pickle.load(filehandler)\n\n                for s in patients + controls:\n                    distance_dict[s] += loaded_dist_dict[s]\n                    distance_fold_count[s] += loaded_dist_count[s]\n\n                print(\"{} ({} folds) will be updated with {} more folds\".format(pickle_file_path, loaded_fold_count, fold_count))\n                true_folds += loaded_fold_count\n\n        with open(pickle_file_path, 'wb') as filehandler:\n            print(\"Saving {}\".format(pickle_file_path))\n            pickle.dump((distance_dict, distance_fold_count, true_folds), filehandler)\n\n        # plot the results\n        \n        # first, obtain the true distance lists from the distance_dict and \n        # distance_fold_count dictionnaries\n        dist_list = []\n        for s in patients:\n            dist_list.append(distance_dict[s] / distance_fold_count[s])\n\n        for c in controls:\n            dist_list.append(distance_dict[c] / distance_fold_count[c])  \n\n        #print(scp.stats.ttest_ind(dist_list[:patients_count], dist_list[patients_count:], equal_var=True))\n        \n        #threshold = 0.0025\n        #print(\"Plot thresholded at {}\".format(threshold))\n        plt.hist(dist_list[:patients_count], stacked=True, density=True, alpha=0.3, label='Patients')\n        plt.hist(dist_list[patients_count:], stacked=True, density=True, alpha = 0.3, label='Controls')\n        sns.kdeplot(dist_list[:patients_count], shade=False, color='C0', alpha=0.3);\n        sns.kdeplot(dist_list[patients_count:], shade=False, color='C1', alpha=0.3);\n        plt.xlabel(\"Distance to barycenter ({:.2f})\".format(ratio))\n        plt.legend()\n        #import tikzplotlib\n        #tikzplotlib.save(\"figures_generation/dist_to_barycenter_full.tex\".format(ratio), wrap=False)\n\n        plt.show()\n\n\ndo_some_folds()\n\n\n", "meta": {"hexsha": "8b43c6a696379643ad7936650c7ec0b0195a4c76", "size": 18618, "ext": "py", "lang": "Python", "max_stars_repo_path": "wasserstein_analysis/barycenter_cross_validation.py", "max_stars_repo_name": "little-nem/brain-connectivity-analysis", "max_stars_repo_head_hexsha": "7d8eb2630bca6e077f38f56dc13b36c83bae9ca3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "wasserstein_analysis/barycenter_cross_validation.py", "max_issues_repo_name": "little-nem/brain-connectivity-analysis", "max_issues_repo_head_hexsha": "7d8eb2630bca6e077f38f56dc13b36c83bae9ca3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-03-20T15:10:35.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-20T15:10:42.000Z", "max_forks_repo_path": "wasserstein_analysis/barycenter_cross_validation.py", "max_forks_repo_name": "little-nem/brain-connectivity-analysis", "max_forks_repo_head_hexsha": "7d8eb2630bca6e077f38f56dc13b36c83bae9ca3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.1514563107, "max_line_length": 264, "alphanum_fraction": 0.6677408959, "include": true, "reason": "import numpy,import scipy,from scipy,import networkx", "num_tokens": 4520, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43782349911420193, "lm_q2_score": 0.13846178168115786, "lm_q1q2_score": 0.06062182174923124}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     formats: py:percent,ipynb\n#     text_representation:\n#       extension: .py\n#       format_name: percent\n#       format_version: '1.3'\n#       jupytext_version: 1.4.2\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# %% [markdown]\n# # 1 Initial Approach with Dynamic Programming\n# This notebook contains some intial trials of hands-on, basic reinforcement learning algorithms to familiarize with the topic and eventually arrive at the bare frame of the environment for ramp-up scenarios. The set-up follows the discourse in [Artificial Intelligence: Reinforcement Learning in Python](https://www.udemy.com/share/1013kmBEQbdF1XTXQ=/) by Lazy Programmer Inc roughly, altough the environment conforms with OpenAI's toolkit for RL, [Gym](https://gym.openai.com/).\n\n# %%\nimport gym\nimport numpy as np\nimport pandas as pd\nfrom gym import spaces\nfrom IPython.core.display import HTML, display\n\n\n# %% [markdown]\n# ## Review helper functions\n\n# %% [markdown]\n# - With `display_side_by_side()`, tables are displayed side by side to ease interpretations and save space as the table index is similar.\n# - Future value at each possible combination of state and episode is generated and displayed with `pivot_v()`\n# - The policy at each possible combination of state and episode is generated and displayed with `pivot_p()`\n\n# %%\ndef display_side_by_side(dfs: list, captions: list):\n    output = \"\"\n    combined = dict(zip(captions, dfs))\n    for caption, df in combined.items():\n        output += (\n            df.style.set_table_attributes(\"style='display:inline'\")\n            .set_caption(caption)\n            ._repr_html_()\n        )\n        output += \"\\xa0\\xa0\\xa0\"\n    display(HTML(output))\n\n\ndef pivot_v(V):\n    v_table = pd.Series(V).reset_index()\n    v_table.columns = [\"Episode\", \"Action\", \"Value\"]\n    v_table.sort_values(by=[\"Episode\", \"Action\"], inplace=True)\n    v_table_p = v_table.pivot(index=\"Episode\", columns=\"Action\")\n    return v_table, v_table_p\n\n\ndef pivot_p(policy):\n    p_table = pd.Series(policy).reset_index()\n    p_table.columns = [\"Episode\", \"State\", \"Policy_S\"]\n    p_table.sort_values(by=[\"Episode\"], inplace=True)\n    p_table = p_table.pivot(index=\"Episode\", columns=\"State\")\n    p_table = p_table.assign(demand=demand)\n    return p_table\n\n\n# %% [markdown]\n# ## Definitions of constants\n#\n# All constants needed for the environment include\n# - the **action list**, a discrete set of actions to move between states\n# - the **legal changes**, a constraining factor which actions may follow upon which state\n# - **demand**, for now just a list which is the trajectory that needs to be followed during an episode, only the choice of actions is open to the agent\n\n# %%\naction_list = [\n    \"OPERATE\",  # 0\n    \"PREPARE\",  # 1\n    \"PARK\",  # 2\n    \"STORE\",  # 3\n]\n\nlegal_changes = {\n    0: {0, 1, 2},  # from OPERATE to OPERATE, PREPARE, or PARK\n    1: {1, 0, 2},  # from PREPARE to PREPARE, OPERATE, or PARK\n    2: {2, 1, 3},  # from PARK to PARK, PREPARE, or STORE\n    3: {3, 2},  # from STORE to STORE or PARK\n}\ndemand = [\n    0,\n    0,\n    0,\n    0,\n    0,\n    0,\n    0,  # week 1\n    0,\n    0,\n    0,\n    2,\n    0,\n    3,\n    1,  # week 2\n    0,\n    0,\n    60,\n    25,\n    32,\n    87,\n    56,  # week 3\n    92,\n    83,\n    29,\n    40,\n    86,\n    70,\n    45,  # week 4\n]\n\n\n# %% [markdown]\n# ## Environment Definition\n# The environment is in accordance with Gym. It's a sequence of X days, on each day a single action can be performed. That's the entire logic encoded in the environment!\n\n# %%\nclass RampupEnv(gym.Env):\n    def __init__(self, horizon=10, verbose=False):\n        super(RampupEnv, self).__init__()\n\n        self.fleet_size = 1\n        self.horizon = horizon\n\n        self.state_time = 0  # time component of state\n        self.state_status = np.zeros(self.horizon)  # status component of state\n\n        # action_space: The Space object corresponding to valid actions\n        # observation_space: The Space object corresponding to valid observations\n        self.action_space = spaces.Discrete(len(action_list))\n        self.observation_space = spaces.Tuple(\n            (spaces.Discrete(self.fleet_size), spaces.Discrete(self.horizon))\n        )\n\n        self.total_reward = 0\n        self.verbose = verbose\n\n    def translate_action(self, action):\n        if action == 0:\n            action_description = \"OPERATE\"\n            if demand[self.state_time] > 80:\n                reward = 15000\n            else:\n                reward = -3000\n        elif action == 1:\n            action_description = \"PREPARE\"\n            reward = -2000\n        elif action == 2:\n            action_description = \"PARK\"\n            reward = -1000\n        elif action == 3:\n            action_description = \"STORE\"\n            reward = -500\n\n        if self.verbose:\n            print(f\"Action {action} leads to state {action_description}\")\n\n        return action_description, reward\n\n    def step(self, action):\n        # Increment time component of state\n        self.state_time += 1\n\n        action_description, reward = self.translate_action(action)\n\n        # Adjust the status component of state\n        self.state_status[self.state_time] = action\n\n        obs = self.state_status[0 : self.state_time]\n        done = bool(self.state_time == self.horizon - 1)\n        info = {}\n\n        if self.verbose:\n            print(f\"Action taken: {action_description}\")\n\n        self.total_reward += reward\n\n        return obs, reward, done, info\n\n    def undo_step(self, o, r, d, i):\n        self.state_time -= 1\n        self.total_reward -= r\n\n        return o, r, d, i\n\n    def render(self):\n        if self.verbose:\n            print(f\"Reward so far: {self.total_reward}\")\n\n    def reset(self):\n        # Initialize the agent in the first field\n        self.state_time = 0\n        self.total_reward = 0\n\n    def set_state(self, state):\n        state_time, state_status = state\n        self.state_time = state_time\n        self.state_status[self.state_time] = state_status\n\n\n# %% [markdown]\n# ## Random Walk Episode\n# The length of the episode is determined by `horizon`, actions are taken at random. We observe, that games mostly lead to a negative total reward, thus it takes a policy better than a random policy to perform well.\n\n# %%\nhorizon = 7 * 4\nenv = RampupEnv(horizon=horizon)\n\nfor step in range(horizon):\n    action = env.action_space.sample()\n    obs, reward, done, info = env.step(action)\n    env.render()\n    if done:\n        print(\n            f\"Random walk episode is complete.\\nTrajectory:\\n{obs}\\nTotal reward: {env.total_reward}\"\n        )\n        break\n\n# %% [markdown]\n# ## Value Iteration\n# All possible state transitions (transitions between possible combinations of state time and state actions) are iteratively evaluated for their value, until the improvement in value converges to a defined threshold. It takes 23 iterations for the sample environment with the provided data. The resulting table shows the value for each state-action.\n\n# %%\nh = 7 * 4  # time horizon\nenv = RampupEnv(horizon=h, verbose=False)\nall_states = set(\n    [(s, a) for s in range(len(env.state_status)) for a in range(env.action_space.n)]\n)\n\nSMALL_ENOUGH = 1e-3  # threshold for convergence\nGAMMA = 1.0  # discount factor\n\nV = {}\nfor state in all_states:\n    V[state] = 0\n\nbiggest_change = 0\niters = 0\n\nwhile True:\n    iters += 1\n    biggest_change = 0\n    for state in all_states:\n        old_v = V[state]\n        env.set_state(state)\n        state_time, state_status = state\n        if env.state_time < env.horizon - 1:\n            new_v = 0  # answer is accumulated\n            p_a = 1.0 / len(legal_changes[state_status])  # equal probability\n            for a in legal_changes[state_status]:\n                env.set_state(state)\n                o, r, d, i = env.step(a)\n                new_v += p_a * (r + GAMMA * V[(env.state_time, a)])\n                o, r, d, i = env.undo_step(o, r, d, i)\n            V[state] = new_v\n            biggest_change = max(biggest_change, np.abs(old_v - V[state]))\n\n        if env.verbose:\n            print(f\"State: {state}, Old V: {old_v}\")\n\n    if biggest_change < SMALL_ENOUGH:\n        print(f\"Done in {iters} iterations\")\n        v_table, v_table_p = pivot_v(V)\n        display(v_table_p)\n        break\n\n# %% [markdown]\n# ## Policy Iteration\n# Value iteration stops as the improvement of value converges, policy iteration then adds a policy improvement step. In the case of the example, there is no improvement visible, but we do get the policy for the values from value iterations inside of the attached policy improvement step.\n\n# %%\nh = 7 * 4  # time horizon\nenv = RampupEnv(horizon=h, verbose=False)\nall_states = set(\n    [(s, a) for s in range(len(env.state_status)) for a in range(env.action_space.n)]\n)\n\nSMALL_ENOUGH = 1e-3\nGAMMA = 1\n\npolicy = {}\nfor state in all_states:\n    policy[state] = env.action_space.sample()\n\nV = {}\nfor state in all_states:\n    V[state] = 0\n\niters1, iters2 = 0, 0\nrep1, rep2 = \"\", \"\"\n\nwhile True:\n    iters1 = 0\n    # Policy Evaluation Step\n    while True:\n        iters1 += 1\n        biggest_change = 0\n        for state in all_states:\n            old_v = V[state]\n            env.set_state(state)\n            state_time, state_status = state\n            if env.state_time < env.horizon - 1:\n                new_v = 0  # answer is accumulated\n                p_a = 1.0 / len(legal_changes[state_status])  # equal probability\n                for a in legal_changes[state_status]:\n                    env.set_state(state)\n                    o, r, d, i = env.step(a)\n                    new_v += p_a * (r + GAMMA * V[(env.state_time, a)])\n                    o, r, d, i = env.undo_step(o, r, d, i)\n                V[state] = new_v\n                biggest_change = max(biggest_change, np.abs(old_v - V[state]))\n\n            if env.verbose:\n                print(f\"State: {state}, Old V: {old_v}\")\n\n        if biggest_change < SMALL_ENOUGH:\n            rep1 += f\"{str(iters1)}, \"\n            iters2 += 1\n            break\n\n    # Policy Improvement Step\n    is_policy_converged = True\n    for state in all_states:\n        for state in policy:\n            old_a = policy[state]\n            new_a = None\n            best_value = float(\"-inf\")\n            env.set_state(state)\n            state_time, state_status = state\n            if env.state_time < env.horizon - 1:\n                # loop through all possible actions to find the best current action\n                for a in legal_changes[state_status]:\n                    env.set_state(state)\n                    o, r, d, i = env.step(a)\n                    v = r + GAMMA * V[(env.state_time, a)]\n                    # print(v)\n                    if v > best_value:\n                        best_value = v\n                        new_a = a\n                policy[state] = new_a\n                if new_a != old_a:\n                    is_policy_converged = False\n    if is_policy_converged:\n        print(\n            f\"Policy evaluation and improvement steps were entered {iters2} times. \\\nPolicy evaluation iterated {rep1[:-2]} times.\"\n        )\n        v_table, v_table_p = pivot_v(V)\n        p_table = pivot_p(policy)\n        display_side_by_side([v_table_p, p_table], [\"Value Table\", \"Policy Table\"])\n        break\n\n# %%\n", "meta": {"hexsha": "a0d3bff9e343cadfab54dece668e8bf206ac4d4c", "size": 11345, "ext": "py", "lang": "Python", "max_stars_repo_path": "nb_01_dynamic_programming.py", "max_stars_repo_name": "sebas-seck/plan-opt", "max_stars_repo_head_hexsha": "bf95edc2c3609aea7572887097be0f2f75e19216", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "nb_01_dynamic_programming.py", "max_issues_repo_name": "sebas-seck/plan-opt", "max_issues_repo_head_hexsha": "bf95edc2c3609aea7572887097be0f2f75e19216", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "nb_01_dynamic_programming.py", "max_forks_repo_name": "sebas-seck/plan-opt", "max_forks_repo_head_hexsha": "bf95edc2c3609aea7572887097be0f2f75e19216", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.3397790055, "max_line_length": 480, "alphanum_fraction": 0.6094314676, "include": true, "reason": "import numpy", "num_tokens": 2888, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.1208532229911838, "lm_q1q2_score": 0.0604266114955919}}
{"text": "r\"\"\"\nFacade Sets\n\"\"\"\n#*****************************************************************************\n#  Copyright (C) 2010 Nicolas M. Thiery <nthiery at users.sf.net>\n#\n#  Distributed under the terms of the GNU General Public License (GPL)\n#                  http://www.gnu.org/licenses/\n#******************************************************************************\n\nfrom sage.misc.cachefunc import cached_method\nfrom sage.categories.category_singleton import Category_singleton\nfrom sage.categories.category import Category\n\nclass FacadeSets(Category_singleton):\n    r\"\"\"\n    The category of facade sets\n\n    A *facade set* is a parent ``P`` whose elements actually belong to\n    some other parent::\n\n        sage: P = Sets().example(); P\n        Set of prime numbers (basic implementation)\n        sage: p = Sets().example().an_element(); p\n        47\n        sage: p in P\n        True\n        sage: p.parent()\n        Integer Ring\n\n    Typical use cases include modeling a subset of an existing\n    parent::\n\n        sage: Sets().Facades().example()\n        An example of facade set: the monoid of positive integers\n\n    or the union of several parents::\n\n        sage: Sets().Facades().example(\"union\")\n        An example of a facade set: the integers completed by +-infinity\n\n    or endowing a parent with more (or less!) structure::\n\n        sage: Posets().example(\"facade\")\n        An example of a facade poset: the positive integers ordered by divisibility\n\n    Let us consider one of the examples above in detail: the partially ordered\n    set `P` of positive integers w.r.t. divisibility order. There are two\n    options for representing its elements:\n\n     1. as plain integers\n     2. as integers, modified to be aware that their parent is `P`\n\n    The advantage of 1. is that one needs not to do conversions back and\n    forth between `P` and `\\ZZ`. The disadvantage is that this\n    introduces an ambiguity when writing `2 < 3`::\n\n        sage: 2 < 3\n        True\n\n    To raise this ambiguity, one needs to explicitely specify the order\n    as in `2 <_P 3`::\n\n\n        sage: P = Posets().example(\"facade\")\n        sage: P.lt(2,3)\n        False\n\n    In short `P` being a facade parent is one of the programmatic\n    counterpart (with e.g. coercions) of the usual mathematical idiom:\n    \"for ease of notation, we identify an element of `P` with the\n    corresponding integer\". Too many identifications lead to\n    confusion; the lack thereof leads to heavy, if not obfuscated,\n    notations. Finding the right balance is an art, and even though\n    there are common guidelines, it is ultimately up to the writer to\n    choose which identifications to do. This is no different in code.\n\n    .. seealso::\n\n       ::\n\n        sage: Sets().example(\"facade\")\n        Set of prime numbers (facade implementation)\n        sage: Sets().example(\"inherits\")\n        Set of prime numbers\n        sage: Sets().example(\"wrapper\")\n        Set of prime numbers (wrapper implementation)\n\n    .. rubric:: Specifications\n\n    A parent which is a facade must either:\n\n    - call :meth:`Parent.__init__` using the ``facade`` parameter to\n      specify a parent, or tuple thereof.\n    - overload the method :meth:`~FacadeSets.ParentMethods.facade_for`.\n\n    .. note:: the concept of facade parents was originally introduced\n       in the computer algebra system MuPAD.\n\n    TESTS:\n\n    Check that multiple categories initialisation works (:trac:`13801`)::\n\n        sage: class A(Parent):\n        ...     def __init__(self):\n        ...         Parent.__init__(self, category=(FiniteEnumeratedSets(),Monoids()), facade=True)\n        sage: a = A()\n    \"\"\"\n\n    @cached_method\n    def super_categories(self):\n        r\"\"\"\n        Returns the super categories of ``self``, as per\n        :meth:`Category.super_categories`.\n\n        EXAMPLES::\n\n            sage: Sets().Facades().super_categories()\n            [Category of sets]\n        \"\"\"\n        from sage.categories.sets_cat import Sets\n        return [Sets()]\n\n    def example(self, choice='subset'):\n        r\"\"\"\n        Returns an example of facade set, as per\n        :meth:`Category.example()\n        <sage.categories.category.Category.example>`.\n\n        INPUT:\n\n        - ``choice`` -- 'union' or 'subset' (default: 'subset').\n\n        EXAMPLES::\n\n            sage: Sets().Facades().example()\n            An example of facade set: the monoid of positive integers\n            sage: Sets().Facades().example(choice='union')\n            An example of a facade set: the integers completed by +-infinity\n            sage: Sets().Facades().example(choice='subset')\n            An example of facade set: the monoid of positive integers\n        \"\"\"\n        import sage.categories.examples.facade_sets as examples\n        if choice == \"union\":\n            return examples.IntegersCompletion()\n        elif choice == 'subset':\n            return examples.PositiveIntegerMonoid()\n        else:\n            raise TypeError, \"choice should be 'union' or 'subset'\"\n\n    class ParentMethods:\n\n        def _element_constructor_(self, element):\n            \"\"\"\n            Coerce ``element`` into ``self``\n\n            INPUT:\n\n            - ``element`` -- any object\n\n            This default implementation returns ``element`` if\n            ``self`` is a facade for ``parent(element)`. Otherwise it\n            attempts in turn to coerce ``element`` into each parent\n            ``self`` is a facade for.\n\n            This implementation is only valid for a facade parent\n            which models the full union of the parents it is a facade\n            for. Other facade parents should redefine\n            :meth:`element_constructor` appropriately.\n\n            EXAMPLES::\n\n                sage: S = Sets().Facades().example(\"union\"); S\n                An example of a facade set: the integers completed by +-infinity\n                sage: S(1)\n                1\n                sage: S(1/2)\n                Traceback (most recent call last):\n                ...\n                ValueError: Can't coerce `1/2` in any parent `An example of a facade set: the integers completed by +-infinity` is a facade for\n                sage: S(2/1)\n                2\n                sage: S(2/1).parent()\n                Integer Ring\n                sage: S(int(1))\n                1\n                sage: S(int(1)).parent()\n                Integer Ring\n\n            Facade parents that model strict subsets should redefine\n            :meth:`element_constructor`::\n\n                sage: S = Sets().Facades().example(); S\n                An example of facade set: the monoid of positive integers\n                sage: S(-1)\n                Traceback (most recent call last):\n                ...\n                ValueError: %s should be positive\n            \"\"\"\n            if self.is_parent_of(element):\n                return element\n            else:\n                parents = self.facade_for()\n                if parents is True:\n                    return NotImplementedError\n                for parent in self.facade_for():\n                    try:\n                        return parent(element)\n                    except Exception:\n                        pass\n            raise ValueError, \"Can't coerce `%s` in any parent `%s` is a facade for\"%(element, self)\n\n        def facade_for(self):\n            \"\"\"\n            Returns the parents this set is a facade for\n\n            This default implementation assumes that ``self`` has\n            an attribute ``_facade_for``, typically initialized by\n            :meth:`Parent.__init__`. If the attribute is not present, the method\n            raises a NotImplementedError.\n\n            EXAMPLES::\n\n                sage: S = Sets().Facades().example(); S\n                An example of facade set: the monoid of positive integers\n                sage: S.facade_for()\n                (Integer Ring,)\n\n            Check that :trac:`13801` is corrected::\n\n                sage: class A(Parent):\n                ...     def __init__(self):\n                ...         Parent.__init__(self, category=Sets(), facade=True)\n                sage: a = A()\n                sage: a.facade_for()\n                Traceback (most recent call last):\n                ...\n                NotImplementedError: this parent did not specify which parents it is a facade for\n            \"\"\"\n            try:\n                return self._facade_for\n            except AttributeError:\n                raise NotImplementedError(\"this parent did not specify which parents it is a facade for\")\n\n        def is_parent_of(self, element):\n            \"\"\"\n            Returns whether ``self`` is the parent of ``element``\n\n            INPUT:\n\n            - ``element`` -- any object\n\n            Since ``self`` is a facade domain, this actually tests\n            whether the parent of ``element`` is any of the parent\n            ``self`` is a facade for.\n\n            EXAMPLES::\n\n                sage: S = Sets().Facades().example(); S\n                An example of facade set: the monoid of positive integers\n                sage: S.is_parent_of(1)\n                True\n                sage: S.is_parent_of(1/2)\n                False\n\n            This method differs from :meth:`__contains__` in two\n            ways.  First, this does not take into account the fact\n            that ``self`` may be a strict subset of the parent(s)\n            it is a facade for::\n\n                sage: -1 in S, S.is_parent_of(-1)\n                (False, True)\n\n            Furthermore, there is no coercion attempted::\n\n                sage: int(1) in S, S.is_parent_of(int(1))\n                (True, False)\n\n            .. warning::\n\n               this implementation does not handle facade parents of facade\n               parents. Is this a feature we want generically?\n            \"\"\"\n            parents = self.facade_for()\n            if parents is True:\n                return True\n            from sage.structure.element import parent\n            return parent(element) in parents\n\n        def __contains__(self, element):\n            \"\"\"\n            Membership testing\n\n            Returns whether ``element`` is in one of the parents\n            ``self`` is a facade for.\n\n            .. warning:: this default implementation is currently\n            overriden by :meth:`Parent.__contains__`.\n\n            EXAMPLES::\n\n                sage: S = Sets().Facades().example(\"union\"); S\n                An example of a facade set: the integers completed by +-infinity\n                sage: 1 in S, -5 in S, oo in S, -oo in S, int(1) in S, 2/1 in S\n                (True, True, True, True, True, True)\n                sage: 1/2 in S, \"bla\" in S\n                (False, False)\n            \"\"\"\n            return any(element in parent for parent in self.facade_for())\n\n        def _an_element_(self):\n            \"\"\"\n            Try to return an element of ``self``, as per\n            :meth:`Sets.ParentMethods.an_element`.\n\n            For each parent ``self`` is a facade for, this default\n            implementation tries the method ``an_element`` until it finds an\n            element in ``self``. If none is found raise a\n            ``NotImplementedError``.\n\n            EXAMPLES::\n\n                sage: S = Sets().Facades().example(); S\n                An example of facade set: the monoid of positive integers\n                sage: S.an_element()\n                1\n            \"\"\"\n            for parent in self.facade_for():\n                x = parent.an_element()\n                if x in self:\n                    return x\n            raise NotImplementedError\n\n\n", "meta": {"hexsha": "647cbf34ec2e5481613d6ad74c48766d45a71c39", "size": 11614, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/categories/facade_sets.py", "max_stars_repo_name": "bopopescu/sagesmc", "max_stars_repo_head_hexsha": "e8d1d31f6f598dba2d763baa2d2e804338f9e89e", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2015-01-04T07:15:06.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T15:15:18.000Z", "max_issues_repo_path": "src/sage/categories/facade_sets.py", "max_issues_repo_name": "bopopescu/sagesmc", "max_issues_repo_head_hexsha": "e8d1d31f6f598dba2d763baa2d2e804338f9e89e", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/categories/facade_sets.py", "max_forks_repo_name": "bopopescu/sagesmc", "max_forks_repo_head_hexsha": "e8d1d31f6f598dba2d763baa2d2e804338f9e89e", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2016-09-28T13:12:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-12T09:28:34.000Z", "avg_line_length": 34.6686567164, "max_line_length": 143, "alphanum_fraction": 0.5530394352, "include": true, "reason": "import sage,from sage", "num_tokens": 2423, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4921881357207956, "lm_q2_score": 0.12252320610998799, "lm_q1q2_score": 0.060304468397809785}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     cell_metadata_filter: collapsed,code_folding\n#     formats: ipynb,py\n#     notebook_metadata_filter: all\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.4'\n#       jupytext_version: 1.2.3\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n#   language_info:\n#     codemirror_mode:\n#       name: ipython\n#       version: 3\n#     file_extension: .py\n#     mimetype: text/x-python\n#     name: python\n#     nbconvert_exporter: python\n#     pygments_lexer: ipython3\n#     version: 3.7.6\n#   latex_envs:\n#     LaTeX_envs_menu_present: true\n#     autoclose: false\n#     autocomplete: true\n#     bibliofile: biblio.bib\n#     cite_by: apalike\n#     current_citInitial: 1\n#     eqLabelWithNumbers: true\n#     eqNumInitial: 1\n#     hotkeys:\n#       equation: Ctrl-E\n#       itemize: Ctrl-I\n#     labels_anchors: false\n#     latex_user_defs: false\n#     report_style_numbering: false\n#     user_envs_cfg: false\n# ---\n\n# # Alternative Combinations of Parameter Values\n#\n# Please write the names and email addresses of everyone who worked on this notebook on the line below.\n#\n# YOUR NAMES HERE\n#\n# ## Introduction\n#\n# The notebook \"Micro-and-Macro-Implications-of-Very-Impatient-HHs\" is an exercise that demonstrates the consequences of changing a key parameter of the [cstwMPC](http://econ.jhu.edu/people/ccarroll/papers/cstwMPC) model, the time preference factor $\\beta$.\n#\n# The [REMARK](https://github.com/econ-ark/REMARK) `SolvingMicroDSOPs` reproduces the last figure in the [SolvingMicroDSOPs](http://econ.jhu.edu/people/ccarroll/SolvingMicroDSOPs) lecture notes, which shows that there are classes of alternate values of $\\beta$ and $\\rho$ that fit the data almost as well as the exact 'best fit' combination.\n#\n# Inspired by this comparison, this notebook asks you to examine the consequences for:\n#\n# * The consumption function\n# * The distribution of wealth\n#\n# Of _joint_ changes in $\\beta$ and $\\rho$ together.  \n#\n# One way you can do this is to construct a list of alternative values of $\\rho$ (say, values that range upward from the default value of $\\rho$, in increments of 0.2, all the way to $\\rho=5$).  Then for each of these values of $\\rho$ you will find the value of $\\beta$ that leads the same value for target market resources, $\\check{m}$.\n#\n# As a reminder, $\\check{m}$ is defined as the value of $m$ at which the optimal value of ${c}$ is the value such that, at that value of ${c}$, the expected level of ${m}$ next period is the same as its current value:\n#\n# $\\mathbb{E}_{t}[{m}_{t+1}] = {m}_{t}$ \n#\n# Other notes:\n# * The cstwMPC model solves and simulates the problems of consumers with 7 different values of $\\beta$\n#    * You should do your exercise using the middle value of $\\beta$ from that exercise: \n#       * `DiscFac_mean   = 0.9855583`\n# * You are likely to run into the problem, as you experiment with parameter values, that you have asked HARK to solve a model that does not satisfy one of the impatience conditions required for the model to have a solution.  Those conditions are explained intuitively in the [TractableBufferStock](http://econ.jhu.edu/people/ccarroll/public/lecturenotes/consumption/TractableBufferStock/) model.  The versions of the impatience conditions that apply to the $\\texttt{IndShockConsumerType}$ model can be found in the paper [BufferStockTheory](http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory), table 2.\n#    * The conditions that need to be satisfied are:\n#       * The Growth Impatience Condition (GIC)\n#       * The Return Impatience Condition (RIC)\n# * Please accumulate the list of solved consumers' problems in a list called `MyTypes`\n#    * For compatibility with a further part of the assignment below\n\n# + {\"code_folding\": []}\n# This cell merely imports and sets up some basic functions and packages \n\n# %matplotlib inline\nimport matplotlib.pyplot as plt\nfrom tqdm import tqdm\nimport numpy as np\nfrom copy import deepcopy\n\nimport HARK # Prevents import error from Demos repo\nfrom HARK.utilities import plotFuncs\n\n# + {\"code_folding\": [0, 4]}\n# Import IndShockConsumerType\nfrom HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n\n# Define a dictionary with calibrated parameters\ncstwMPC_calibrated_parameters = {\n    \"CRRA\":1.0,                    # Coefficient of relative risk aversion \n    \"Rfree\":1.01/(1.0 - 1.0/160.0), # Survival probability,\n    \"PermGroFac\":[1.000**0.25], # Permanent income growth factor (no perm growth),\n    \"PermGroFacAgg\":1.0,\n    \"BoroCnstArt\":0.0,\n    \"CubicBool\":False,\n    \"vFuncBool\":False,\n    \"PermShkStd\":[(0.01*4/11)**0.5],  # Standard deviation of permanent shocks to income\n    \"PermShkCount\":5,  # Number of points in permanent income shock grid\n    \"TranShkStd\":[(0.01*4)**0.5],  # Standard deviation of transitory shocks to income,\n    \"TranShkCount\":5,  # Number of points in transitory income shock grid\n    \"UnempPrb\":0.07,  # Probability of unemployment while working\n    \"IncUnemp\":0.15,  # Unemployment benefit replacement rate\n    \"UnempPrbRet\":None,\n    \"IncUnempRet\":None,\n    \"aXtraMin\":0.00001,  # Minimum end-of-period assets in grid\n    \"aXtraMax\":40,  # Maximum end-of-period assets in grid\n    \"aXtraCount\":32,  # Number of points in assets grid\n    \"aXtraExtra\":[None],\n    \"aXtraNestFac\":3,  # Number of times to 'exponentially nest' when constructing assets grid\n    \"LivPrb\":[1.0 - 1.0/160.0],  # Survival probability\n    \"DiscFac\":0.97,             # Default intertemporal discount factor; dummy value, will be overwritten\n    \"cycles\":0,\n    \"T_cycle\":1,\n    \"T_retire\":0,\n    'T_sim':1200,  # Number of periods to simulate (idiosyncratic shocks model, perpetual youth)\n    'T_age': 400,\n    'IndL': 10.0/9.0,  # Labor supply per individual (constant),\n    'aNrmInitMean':np.log(0.00001),\n    'aNrmInitStd':0.0,\n    'pLvlInitMean':0.0,\n    'pLvlInitStd':0.0,\n    'AgentCount':10000,\n}\n# -\n\n# Construct a list of solved consumers' problems, IndShockConsumerType is just a place holder\nMyTypes = [IndShockConsumerType(**cstwMPC_calibrated_parameters)]\n\n# ## Simulating the Distribution of Wealth for Alternative Combinations\n#\n# You should now have constructed a list of consumer types all of whom have the same _target_ level of market resources $\\check{m}$.  \n#\n# But the fact that everyone has the same target ${m}$ does not mean that the _distribution_ of ${m}$ will be the same for all of these consumer types.\n#\n# In the code block below, fill in the contents of the loop to solve and simulate each agent type for many periods.  To do this, you should invoke the methods $\\texttt{solve}$, $\\texttt{initializeSim}$, and $\\texttt{simulate}$ in that order.  Simulating for 1200 quarters (300 years) will approximate the long run distribution of wealth in the population. \n\nfor ThisType in tqdm(MyTypes):\n    ThisType.solve()\n    ThisType.initializeSim()\n    ThisType.simulate()\n\n# Now that you have solved and simulated these consumers, make a plot that shows the relationship between your alternative values of $\\rho$ and the mean level of assets \n\n# +\n# To help you out, we have given you the command needed to construct a list of the levels of assets for all consumers\naLvl_all = np.concatenate([ThisType.aLvlNow for ThisType in MyTypes])\n\n# You should take the mean of aLvl for each consumer in MyTypes, divide it by the mean across all simulations\n# and then plot the ratio of the values of mean(aLvl) for each group against the value of $\\rho$ \n# -\n\n# # Interpret\n# Here, you should attempt to give an intiutive explanation of the results you see in the figure you just constructed\n\n# ## The Distribution of Wealth...\n#\n# Your next exercise is to show how the distribution of wealth differs for the different parameter  values \n\n# +\nfrom HARK.utilities import getLorenzShares, getPercentiles\n\n# Finish filling in this function to calculate the Euclidean distance between the simulated and actual Lorenz curves.\ndef calcLorenzDistance(SomeTypes):\n    '''\n    Calculates the Euclidean distance between the simulated and actual (from SCF data) Lorenz curves at the\n    20th, 40th, 60th, and 80th percentiles.\n    \n    Parameters\n    ----------\n    SomeTypes : [AgentType]\n        List of AgentTypes that have been solved and simulated.  Current levels of individual assets should\n        be stored in the attribute aLvlNow.\n        \n    Returns\n    -------\n    lorenz_distance : float\n        Euclidean distance (square root of sum of squared differences) between simulated and actual Lorenz curves.\n    '''\n    # Define empirical Lorenz curve points\n    lorenz_SCF = np.array([-0.00183091,  0.0104425 ,  0.0552605 ,  0.1751907 ])\n    \n    # Extract asset holdings from all consumer types\n    aLvl_sim = np.concatenate([ThisType.aLvlNow for ThisType in MyTypes])\n    \n    # Calculate simulated Lorenz curve points\n    lorenz_sim = getLorenzShares(aLvl_sim,percentiles=[0.2,0.4,0.6,0.8])\n    \n    # Calculate the Euclidean distance between the simulated and actual Lorenz curves\n    lorenz_distance = np.sqrt(np.sum((lorenz_SCF - lorenz_sim)**2))\n    \n    # Return the Lorenz distance\n    return lorenz_distance\n\n\n# -\n\n# ## ...and the Marginal Propensity to Consume\n#\n# Now let's look at the aggregate MPC.  In the code block below, write a function that produces text output of the following form:\n#\n# $\\texttt{The 35th percentile of the MPC is 0.15623}$\n#\n# Your function should take two inputs: a list of types of consumers and an array of percentiles (numbers between 0 and 1). It should return no outputs, merely print to screen one line of text for each requested percentile.  The model is calibrated at a quarterly frequency, but Carroll et al report MPCs at an annual frequency. To convert, use the formula:\n#\n# $\\kappa_{Y} \\approx 1.0 - (1.0 - \\kappa_{Q})^4$\n\n# +\n# Write a function to tell us about the distribution of the MPC in this code block, then test it!\n# You will almost surely find it useful to use a for loop in this function.\ndef describeMPCdstn(SomeTypes,percentiles):\n    MPC_sim = np.concatenate([ThisType.MPCnow for ThisType in SomeTypes])\n    MPCpercentiles_quarterly = getPercentiles(MPC_sim,percentiles=percentiles)\n    MPCpercentiles_annual = 1.0 - (1.0 - MPCpercentiles_quarterly)**4\n    \n    for j in range(len(percentiles)):\n        print('The ' + str(100*percentiles[j]) + 'th percentile of the MPC is ' + str(MPCpercentiles_annual[j]))\n        \ndescribeMPCdstn(MyTypes,np.linspace(0.05,0.95,19))\n# -\n\n# # If You Get Here ...\n#\n# If you have finished the above exercises quickly and have more time to spend on this assignment, for extra credit you can do the same exercise where, instead of exploring the consequences of alternative values of relative risk aversion $\\rho$, you should test the consequences of different values of the growth factor $\\Gamma$ that lead to the same $\\check{m}$.\n\n\n", "meta": {"hexsha": "0b91d26679842537021fd7a33d941a3fb4dd659c", "size": 10927, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks/Alternative-Combos-Of-Parameter-Values.py", "max_stars_repo_name": "frankovici/DemARK", "max_stars_repo_head_hexsha": "177c09bd387160d06f979c417671b3de18746846", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/Alternative-Combos-Of-Parameter-Values.py", "max_issues_repo_name": "frankovici/DemARK", "max_issues_repo_head_hexsha": "177c09bd387160d06f979c417671b3de18746846", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "notebooks/Alternative-Combos-Of-Parameter-Values.py", "max_forks_repo_name": "frankovici/DemARK", "max_forks_repo_head_hexsha": "177c09bd387160d06f979c417671b3de18746846", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.6965811966, "max_line_length": 613, "alphanum_fraction": 0.7198682163, "include": true, "reason": "import numpy", "num_tokens": 2936, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.45326184801538616, "lm_q2_score": 0.13296423504419935, "lm_q1q2_score": 0.060267614896085966}}
{"text": "\"\"\"\nSets\n\nAUTHORS:\n\n- William Stein (2005) - first version\n\n- William Stein (2006-02-16) - large number of documentation and\n  examples; improved code\n\n- Mike Hansen (2007-3-25) - added differences and symmetric\n  differences; fixed operators\n\n- Florent Hivert (2010-06-17) - Adapted to categories\n\n- Nicolas M. Thiery (2011-03-15) - Added subset and superset methods\n\n- Julian Rueth (2013-04-09) - Collected common code in\n  :class:`Set_object_binary`, fixed ``__hash__``.\n\n\"\"\"\n\n#*****************************************************************************\n#       Copyright (C) 2005 William Stein <wstein@gmail.com>\n#                     2013 Julian Rueth <julian.rueth@fsfe.org>\n#\n#  Distributed under the terms of the GNU General Public License (GPL)\n#\n#    This code is distributed in the hope that it will be useful,\n#    but WITHOUT ANY WARRANTY; without even the implied warranty of\n#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n#    General Public License for more details.\n#\n#  The full text of the GPL is available at:\n#\n#                  http://www.gnu.org/licenses/\n#*****************************************************************************\nfrom __future__ import print_function\nimport six\nfrom six import integer_types\n\nfrom sage.misc.latex import latex\nfrom sage.misc.prandom import choice\n\nfrom sage.structure.category_object import CategoryObject\nfrom sage.structure.element import Element\nfrom sage.structure.parent import Parent, Set_generic\nfrom sage.structure.richcmp import richcmp_method, richcmp, rich_to_bool\n\nfrom sage.categories.sets_cat import Sets\nfrom sage.categories.enumerated_sets import EnumeratedSets\n\nimport sage.rings.infinity\n\n\ndef has_finite_length(obj):\n    \"\"\"\n    Return ``True`` if ``obj`` is known to have finite length.\n\n    This is mainly meant for pure Python types, so we do not call any\n    Sage-specific methods.\n\n    EXAMPLES::\n\n        sage: from sage.sets.set import has_finite_length\n        sage: has_finite_length(tuple(range(10)))\n        True\n        sage: has_finite_length(list(range(10)))\n        True\n        sage: has_finite_length(set(range(10)))\n        True\n        sage: has_finite_length(iter(range(10)))\n        False\n        sage: has_finite_length(GF(17^127))\n        True\n        sage: has_finite_length(ZZ)\n        False\n    \"\"\"\n    try:\n        len(obj)\n    except OverflowError:\n        return True\n    except Exception:\n        return False\n    else:\n        return True\n\n\ndef Set(X=[]):\n    r\"\"\"\n    Create the underlying set of ``X``.\n\n    If ``X`` is a list, tuple, Python set, or ``X.is_finite()`` is\n    ``True``, this returns a wrapper around Python's enumerated immutable\n    ``frozenset`` type with extra functionality.  Otherwise it returns a\n    more formal wrapper.\n\n    If you need the functionality of mutable sets, use Python's\n    builtin set type.\n\n    EXAMPLES::\n\n        sage: X = Set(GF(9,'a'))\n        sage: X\n        {0, 1, 2, a, a + 1, a + 2, 2*a, 2*a + 1, 2*a + 2}\n        sage: type(X)\n        <class 'sage.sets.set.Set_object_enumerated_with_category'>\n        sage: Y = X.union(Set(QQ))\n        sage: Y\n        Set-theoretic union of {0, 1, 2, a, a + 1, a + 2, 2*a, 2*a + 1, 2*a + 2} and Set of elements of Rational Field\n        sage: type(Y)\n        <class 'sage.sets.set.Set_object_union_with_category'>\n\n    Usually sets can be used as dictionary keys.\n\n    ::\n\n        sage: d={Set([2*I,1+I]):10}\n        sage: d                  # key is randomly ordered\n        {{I + 1, 2*I}: 10}\n        sage: d[Set([1+I,2*I])]\n        10\n        sage: d[Set((1+I,2*I))]\n        10\n\n    The original object is often forgotten.\n\n    ::\n\n        sage: v = [1,2,3]\n        sage: X = Set(v)\n        sage: X\n        {1, 2, 3}\n        sage: v.append(5)\n        sage: X\n        {1, 2, 3}\n        sage: 5 in X\n        False\n\n    Set also accepts iterators, but be careful to only give *finite*\n    sets::\n\n        sage: from six.moves import range\n        sage: sorted(Set(range(1,6)))\n        [1, 2, 3, 4, 5]\n        sage: sorted(Set(list(range(1,6))))\n        [1, 2, 3, 4, 5]\n        sage: sorted(Set(iter(range(1,6))))\n        [1, 2, 3, 4, 5]\n\n    We can also create sets from different types::\n\n        sage: sorted(Set([Sequence([3,1], immutable=True), 5, QQ, Partition([3,1,1])]), key=str)\n        [5, Rational Field, [3, 1, 1], [3, 1]]\n\n    Sets with unhashable objects work, but with less functionality::\n\n        sage: A = Set([QQ, (3, 1), 5])  # hashable\n        sage: sorted(A.list(), key=repr)\n        [(3, 1), 5, Rational Field]\n        sage: type(A)\n        <class 'sage.sets.set.Set_object_enumerated_with_category'>\n        sage: B = Set([QQ, [3, 1], 5])  # unhashable\n        sage: sorted(B.list(), key=repr)\n        Traceback (most recent call last):\n        ...\n        AttributeError: 'Set_object_with_category' object has no attribute 'list'\n        sage: type(B)\n        <class 'sage.sets.set.Set_object_with_category'>\n\n    TESTS::\n\n        sage: Set(Primes())\n        Set of all prime numbers: 2, 3, 5, 7, ...\n        sage: Set(Subsets([1,2,3])).cardinality()\n        8\n        sage: S = Set(iter([1,2,3])); S\n        {1, 2, 3}\n        sage: type(S)\n        <class 'sage.sets.set.Set_object_enumerated_with_category'>\n        sage: S = Set([])\n        sage: TestSuite(S).run()\n\n    Check that :trac:`16090` is fixed::\n\n        sage: Set()\n        {}\n    \"\"\"\n    if isinstance(X, CategoryObject):\n        if isinstance(X, Set_generic):\n            return X\n        elif X in Sets().Finite():\n            return Set_object_enumerated(X)\n        else:\n            return Set_object(X)\n\n    if isinstance(X, Element):\n        raise TypeError(\"Element has no defined underlying set\")\n\n    try:\n        X = frozenset(X)\n    except TypeError:\n        return Set_object(X)\n    else:\n        return Set_object_enumerated(X)\n\n\n@richcmp_method\nclass Set_object(Set_generic):\n    r\"\"\"\n    A set attached to an almost arbitrary object.\n\n    EXAMPLES::\n\n        sage: K = GF(19)\n        sage: Set(K)\n        {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}\n        sage: S = Set(K)\n\n        sage: latex(S)\n        \\left\\{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18\\right\\}\n        sage: TestSuite(S).run()\n\n        sage: latex(Set(ZZ))\n        \\Bold{Z}\n\n    TESTS:\n\n    See trac ticket :trac:`14486`::\n\n        sage: 0 == Set([1]), Set([1]) == 0\n        (False, False)\n        sage: 1 == Set([0]), Set([0]) == 1\n        (False, False)\n    \"\"\"\n    def __init__(self, X, category=None):\n        \"\"\"\n        Create a Set_object\n\n        This function is called by the Set function; users\n        shouldn't call this directly.\n\n        EXAMPLES::\n\n            sage: type(Set(QQ))\n            <class 'sage.sets.set.Set_object_with_category'>\n            sage: Set(QQ).category()\n            Category of sets\n\n        TESTS::\n\n            sage: _a, _b = get_coercion_model().canonical_coercion(Set([0]), 0)\n            Traceback (most recent call last):\n            ...\n            TypeError: no common canonical parent for objects with parents:\n            '<class 'sage.sets.set.Set_object_enumerated_with_category'>'\n            and 'Integer Ring'\n        \"\"\"\n        from sage.rings.integer import is_Integer\n        if isinstance(X, integer_types) or is_Integer(X):\n            # The coercion model will try to call Set_object(0)\n            raise ValueError('underlying object cannot be an integer')\n\n        if category is None:\n            category = Sets()\n        Parent.__init__(self, category=category)\n        self.__object = X\n\n    def __hash__(self):\n        \"\"\"\n        Return the hash value of ``self``.\n\n        EXAMPLES::\n\n            sage: hash(Set(QQ)) == hash(QQ)\n            True\n        \"\"\"\n        return hash(self.__object)\n\n    def _latex_(self):\n        r\"\"\"\n        Return latex representation of this set.\n\n        This is often the same as the latex representation of this\n        object when the object is infinite.\n\n        EXAMPLES::\n\n            sage: latex(Set(QQ))\n            \\Bold{Q}\n\n        When the object is finite or a special set then the latex\n        representation can be more interesting.\n\n        ::\n\n            sage: print(latex(Primes()))\n            \\text{\\texttt{Set{ }of{ }all{ }prime{ }numbers:{ }2,{ }3,{ }5,{ }7,{ }...}}\n            sage: print(latex(Set([1,1,1,5,6])))\n            \\left\\{1, 5, 6\\right\\}\n        \"\"\"\n        return latex(self.__object)\n\n    def _repr_(self):\n        \"\"\"\n        Print representation of this set.\n\n        EXAMPLES::\n\n            sage: X = Set(ZZ)\n            sage: X\n            Set of elements of Integer Ring\n            sage: X.rename('{ integers }')\n            sage: X\n            { integers }\n        \"\"\"\n        return \"Set of elements of \" + repr(self.__object)\n\n    def __iter__(self):\n        \"\"\"\n        Iterate over the elements of this set.\n\n        EXAMPLES::\n\n            sage: X = Set(ZZ)\n            sage: I = X.__iter__()\n            sage: next(I)\n            0\n            sage: next(I)\n            1\n            sage: next(I)\n            -1\n            sage: next(I)\n            2\n        \"\"\"\n        return iter(self.__object)\n\n    an_element = EnumeratedSets.ParentMethods.__dict__['_an_element_from_iterator']\n\n    def __contains__(self, x):\n        \"\"\"\n        Return ``True`` if `x` is in ``self``.\n\n        EXAMPLES::\n\n            sage: X = Set(ZZ)\n            sage: 5 in X\n            True\n            sage: GF(7)(3) in X\n            True\n            sage: 2/1 in X\n            True\n            sage: 2/1 in ZZ\n            True\n            sage: 2/3 in X\n            False\n\n        Finite fields better illustrate the difference between\n        ``__contains__`` for objects and their underlying sets.\n\n            sage: X = Set(GF(7))\n            sage: X\n            {0, 1, 2, 3, 4, 5, 6}\n            sage: 5/3 in X\n            False\n            sage: 5/3 in GF(7)\n            False\n            sage: sorted(Set(GF(7)).union(Set(GF(5))), key=int)\n            [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 6]\n            sage: Set(GF(7)).intersection(Set(GF(5)))\n            {}\n        \"\"\"\n        return x in self.__object\n\n    def __richcmp__(self, right, op):\n        r\"\"\"\n        Compare ``self`` and ``right``.\n\n        If ``right`` is not a :class:`Set_object`, return ``NotImplemented``.\n        If ``right`` is also a :class:`Set_object`, returns comparison\n        on the underlying objects.\n\n        .. NOTE::\n\n           If `X < Y` is true this does *not* necessarily mean\n           that `X` is a subset of `Y`.  Also, any two sets can be\n           compared still, but the result need not be meaningful\n           if they are not equal.\n\n        EXAMPLES::\n\n            sage: Set(ZZ) == Set(QQ)\n            False\n            sage: Set(ZZ) < Set(QQ)\n            True\n            sage: Primes() == Set(QQ)\n            False\n\n        The following is random, illustrating that comparison of\n        sets is not the subset relation, when they are not equal::\n\n            sage: Primes() < Set(QQ)             # random  # py2\n            True or False\n        \"\"\"\n        if not isinstance(right, Set_object):\n            return NotImplemented\n        return richcmp(self.__object, right.__object, op)\n\n    def union(self, X):\n        \"\"\"\n        Return the union of ``self`` and ``X``.\n\n        EXAMPLES::\n\n            sage: Set(QQ).union(Set(ZZ))\n            Set-theoretic union of Set of elements of Rational Field and Set of elements of Integer Ring\n            sage: Set(QQ) + Set(ZZ)\n            Set-theoretic union of Set of elements of Rational Field and Set of elements of Integer Ring\n            sage: X = Set(QQ).union(Set(GF(3))); X\n            Set-theoretic union of Set of elements of Rational Field and {0, 1, 2}\n            sage: 2/3 in X\n            True\n            sage: GF(3)(2) in X\n            True\n            sage: GF(5)(2) in X\n            False\n            sage: sorted(Set(GF(7)) + Set(GF(3)), key=int)\n            [0, 0, 1, 1, 2, 2, 3, 4, 5, 6]\n        \"\"\"\n        if isinstance(X, Set_generic):\n            if self is X:\n                return self\n            return Set_object_union(self, X)\n        raise TypeError(\"X (=%s) must be a Set\"%X)\n\n    def __add__(self, X):\n        \"\"\"\n        Return the union of ``self`` and ``X``.\n\n        EXAMPLES::\n\n            sage: Set(RealField()) + Set(QQ^5)\n             Set-theoretic union of Set of elements of Real Field with 53 bits of precision and Set of elements of Vector space of dimension 5 over Rational Field\n            sage: Set(GF(3)) + Set(GF(2))\n            {0, 1, 2, 0, 1}\n            sage: Set(GF(2)) + Set(GF(4,'a'))\n            {0, 1, a, a + 1}\n            sage: sorted(Set(GF(8,'b')) + Set(GF(4,'a')), key=str)\n            [0, 0, 1, 1, a, a + 1, b, b + 1, b^2, b^2 + 1, b^2 + b, b^2 + b + 1]\n        \"\"\"\n        return self.union(X)\n\n    def __or__(self, X):\n        \"\"\"\n        Return the union of ``self`` and ``X``.\n\n        EXAMPLES::\n\n            sage: Set([2,3]) | Set([3,4])\n            {2, 3, 4}\n            sage: Set(ZZ) | Set(QQ)\n            Set-theoretic union of Set of elements of Integer Ring and Set of elements of Rational Field\n        \"\"\"\n\n        return self.union(X)\n\n    def intersection(self, X):\n        r\"\"\"\n        Return the intersection of ``self`` and ``X``.\n\n        EXAMPLES::\n\n            sage: X = Set(ZZ).intersection(Primes())\n            sage: 4 in X\n            False\n            sage: 3 in X\n            True\n\n            sage: 2/1 in X\n            True\n\n            sage: X = Set(GF(9,'b')).intersection(Set(GF(27,'c')))\n            sage: X\n            {}\n\n            sage: X = Set(GF(9,'b')).intersection(Set(GF(27,'b')))\n            sage: X\n            {}\n        \"\"\"\n        if isinstance(X, Set_generic):\n            if self is X:\n                return self\n            return Set_object_intersection(self, X)\n        raise TypeError(\"X (=%s) must be a Set\"%X)\n\n\n    def difference(self, X):\n        r\"\"\"\n        Return the set difference ``self - X``.\n\n        EXAMPLES::\n\n            sage: X = Set(ZZ).difference(Primes())\n            sage: 4 in X\n            True\n            sage: 3 in X\n            False\n\n            sage: 4/1 in X\n            True\n\n            sage: X = Set(GF(9,'b')).difference(Set(GF(27,'c')))\n            sage: X\n            {0, 1, 2, b, b + 1, b + 2, 2*b, 2*b + 1, 2*b + 2}\n\n            sage: X = Set(GF(9,'b')).difference(Set(GF(27,'b')))\n            sage: X\n            {0, 1, 2, b, b + 1, b + 2, 2*b, 2*b + 1, 2*b + 2}\n        \"\"\"\n        if isinstance(X, Set_generic):\n            if self is X:\n                return Set([])\n            return Set_object_difference(self, X)\n        raise TypeError(\"X (=%s) must be a Set\"%X)\n\n    def symmetric_difference(self, X):\n        r\"\"\"\n        Returns the symmetric difference of ``self`` and ``X``.\n\n        EXAMPLES::\n\n            sage: X = Set([1,2,3]).symmetric_difference(Set([3,4]))\n            sage: X\n            {1, 2, 4}\n        \"\"\"\n\n        if isinstance(X, Set_generic):\n            if self is X:\n                return Set([])\n            return Set_object_symmetric_difference(self, X)\n        raise TypeError(\"X (=%s) must be a Set\"%X)\n\n\n    def __sub__(self, X):\n        \"\"\"\n        Return the difference of ``self`` and ``X``.\n\n        EXAMPLES::\n\n            sage: X = Set(ZZ).difference(Primes())\n            sage: Y = Set(ZZ) - Primes()\n            sage: X == Y\n            True\n        \"\"\"\n        return self.difference(X)\n\n    def __and__(self, X):\n        \"\"\"\n        Returns the intersection of ``self`` and ``X``.\n\n        EXAMPLES::\n\n            sage: Set([2,3]) & Set([3,4])\n            {3}\n            sage: Set(ZZ) & Set(QQ)\n            Set-theoretic intersection of Set of elements of Integer Ring and Set of elements of Rational Field\n        \"\"\"\n\n        return self.intersection(X)\n\n    def __xor__(self, X):\n        \"\"\"\n        Returns the symmetric difference of ``self`` and ``X``.\n\n        EXAMPLES::\n\n            sage: X = Set([1,2,3,4])\n            sage: Y = Set([1,2])\n            sage: X.symmetric_difference(Y)\n            {3, 4}\n            sage: X.__xor__(Y)\n            {3, 4}\n        \"\"\"\n        return self.symmetric_difference(X)\n\n    def cardinality(self):\n        \"\"\"\n        Return the cardinality of this set, which is either an integer or\n        ``Infinity``.\n\n        EXAMPLES::\n\n            sage: Set(ZZ).cardinality()\n            +Infinity\n            sage: Primes().cardinality()\n            +Infinity\n            sage: Set(GF(5)).cardinality()\n            5\n            sage: Set(GF(5^2,'a')).cardinality()\n            25\n        \"\"\"\n        if not self.is_finite():\n            return sage.rings.infinity.infinity\n\n        if self is not self.__object:\n            try:\n                return self.__object.cardinality()\n            except (AttributeError, NotImplementedError):\n                pass\n            from sage.rings.integer import Integer\n            try:\n                return Integer(len(self.__object))\n            except TypeError:\n                pass\n\n        raise NotImplementedError(\"computation of cardinality of %s not yet implemented\"%self.__object)\n\n    def is_empty(self):\n        \"\"\"\n        Return boolean representing emptiness of the set.\n\n        OUTPUT:\n\n        True if the set is empty, False if otherwise.\n\n        EXAMPLES::\n\n            sage: Set([]).is_empty()\n            True\n            sage: Set([0]).is_empty()\n            False\n            sage: Set([1..100]).is_empty()\n            False\n            sage: Set(SymmetricGroup(2).list()).is_empty()\n            False\n            sage: Set(ZZ).is_empty()\n            False\n\n        TESTS::\n\n            sage: Set([]).is_empty()\n            True\n            sage: Set([1,2,3]).is_empty()\n            False\n            sage: Set([1..100]).is_empty()\n            False\n            sage: Set(DihedralGroup(4).list()).is_empty()\n            False\n            sage: Set(QQ).is_empty()\n            False\n        \"\"\"\n        return not self\n\n    def is_finite(self):\n        \"\"\"\n        Return ``True`` if ``self`` is finite.\n\n        EXAMPLES::\n\n            sage: Set(QQ).is_finite()\n            False\n            sage: Set(GF(250037)).is_finite()\n            True\n            sage: Set(Integers(2^1000000)).is_finite()\n            True\n            sage: Set([1,'a',ZZ]).is_finite()\n            True\n        \"\"\"\n        obj = self.__object\n        try:\n            is_finite = obj.is_finite\n        except AttributeError:\n            return has_finite_length(obj)\n        else:\n            return is_finite()\n\n    def object(self):\n        \"\"\"\n        Return underlying object.\n\n        EXAMPLES::\n\n            sage: X = Set(QQ)\n            sage: X.object()\n            Rational Field\n            sage: X = Primes()\n            sage: X.object()\n            Set of all prime numbers: 2, 3, 5, 7, ...\n        \"\"\"\n        return self.__object\n\n    def subsets(self,size=None):\n        \"\"\"\n        Return the :class:`Subsets` object representing the subsets of a set.\n        If size is specified, return the subsets of that size.\n\n        EXAMPLES::\n\n            sage: X = Set([1,2,3])\n            sage: list(X.subsets())\n            [{}, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}]\n            sage: list(X.subsets(2))\n            [{1, 2}, {1, 3}, {2, 3}]\n\n        \"\"\"\n        from sage.combinat.subset import Subsets\n        return Subsets(self,size)\n\n\nclass Set_object_enumerated(Set_object):\n    \"\"\"\n    A finite enumerated set.\n    \"\"\"\n    def __init__(self, X):\n        r\"\"\"\n        Initialize ``self``.\n\n        EXAMPLES::\n\n            sage: S = Set(GF(19)); S\n            {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}\n            sage: S.category()\n            Category of finite sets\n            sage: print(latex(S))\n            \\left\\{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18\\right\\}\n            sage: TestSuite(S).run()\n        \"\"\"\n        Set_object.__init__(self, X, category=Sets().Finite())\n\n    def random_element(self):\n        r\"\"\"\n        Return a random element in this set.\n\n        EXAMPLES::\n\n            sage: Set([1,2,3]).random_element() # random\n            2\n        \"\"\"\n        try:\n            return self.object().random_element()\n        except AttributeError:\n            # TODO: this very slow!\n            return choice(self.list())\n\n    def is_finite(self):\n        r\"\"\"\n        Return ``True`` as this is a finite set.\n\n        EXAMPLES::\n\n            sage: Set(GF(19)).is_finite()\n            True\n        \"\"\"\n        return True\n\n    def cardinality(self):\n        \"\"\"\n        Return the cardinality of ``self``.\n\n        EXAMPLES::\n\n            sage: Set([1,1]).cardinality()\n            1\n        \"\"\"\n        from sage.rings.integer import Integer\n        return Integer(len(self.set()))\n\n    def __len__(self):\n        \"\"\"\n        EXAMPLES::\n\n            sage: len(Set([1,1]))\n            1\n        \"\"\"\n        return len(self.set())\n\n    def __iter__(self):\n        r\"\"\"\n        Iterating through the elements of ``self``.\n\n        EXAMPLES::\n\n            sage: S = Set(GF(19))\n            sage: I = iter(S)\n            sage: next(I)\n            0\n            sage: next(I)\n            1\n            sage: next(I)\n            2\n            sage: next(I)\n            3\n        \"\"\"\n        return iter(self.set())\n\n    def _latex_(self):\n        r\"\"\"\n        Return the LaTeX representation of ``self``.\n\n        EXAMPLES::\n\n            sage: S = Set(GF(2))\n            sage: latex(S)\n            \\left\\{0, 1\\right\\}\n        \"\"\"\n        return '\\\\left\\\\{' + ', '.join([latex(x) for x in self.set()])  + '\\\\right\\\\}'\n\n    def _repr_(self):\n        r\"\"\"\n        Return the string representation of ``self``.\n\n        EXAMPLES::\n\n            sage: S = Set(GF(2))\n            sage: S\n            {0, 1}\n\n        TESTS::\n\n            sage: Set()\n            {}\n        \"\"\"\n        py_set = self.set()\n        if six.PY3:\n            if not py_set:\n                return \"{}\"\n            return repr(py_set)\n        else:\n            return \"{\" + repr(py_set)[5:-2] + \"}\"\n\n    def list(self):\n        \"\"\"\n        Return the elements of ``self``, as a list.\n\n        EXAMPLES::\n\n            sage: X = Set(GF(8,'c'))\n            sage: X\n            {0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1}\n            sage: X.list()\n            [0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1]\n            sage: type(X.list())\n            <... 'list'>\n\n        .. TODO::\n\n            FIXME: What should be the order of the result?\n            That of ``self.object()``? Or the order given by\n            ``set(self.object())``? Note that :meth:`__getitem__` is\n            currently implemented in term of this list method, which\n            is really inefficient ...\n        \"\"\"\n        return list(set(self.object()))\n\n    def set(self):\n        \"\"\"\n        Return the Python set object associated to this set.\n\n        Python has a notion of finite set, and often Sage sets\n        have an associated Python set.  This function returns\n        that set.\n\n        EXAMPLES::\n\n            sage: X = Set(GF(8,'c'))\n            sage: X\n            {0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1}\n            sage: X.set()\n            {0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1}\n            sage: type(X.set())\n            <... 'set'>\n            sage: type(X)\n            <class 'sage.sets.set.Set_object_enumerated_with_category'>\n        \"\"\"\n        return set(self.object())\n\n    def frozenset(self):\n        \"\"\"\n        Return the Python frozenset object associated to this set,\n        which is an immutable set (hence hashable).\n\n        EXAMPLES::\n\n            sage: X = Set(GF(8,'c'))\n            sage: X\n            {0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1}\n            sage: s = X.set(); s\n            {0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1}\n            sage: hash(s)\n            Traceback (most recent call last):\n            ...\n            TypeError: unhashable type: 'set'\n            sage: s = X.frozenset(); s\n            frozenset({0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1})\n\n            sage: hash(s) != hash(tuple(X.set()))\n            True\n\n            sage: type(s)\n            <... 'frozenset'>\n        \"\"\"\n        return frozenset(self.object())\n\n    def __hash__(self):\n        \"\"\"\n        Return the hash of ``self`` (as a ``frozenset``).\n\n        EXAMPLES::\n\n            sage: s = Set(GF(8,'c'))\n            sage: hash(s) == hash(s)\n            True\n        \"\"\"\n        return hash(self.frozenset())\n\n    def __richcmp__(self, other, op):\n        \"\"\"\n        Compare the sets ``self`` and ``other``.\n\n        EXAMPLES::\n\n            sage: X = Set(GF(8,'c'))\n            sage: X == Set(GF(8,'c'))\n            True\n            sage: X == Set(GF(4,'a'))\n            False\n            sage: Set(QQ) == Set(ZZ)\n            False\n            sage: Set([1]) == set([1])\n            True\n        \"\"\"\n        if not isinstance(other, Set_object_enumerated):\n            if isinstance(other, (set, frozenset)):\n                return self.set() == other\n            return NotImplemented\n        if self.set() == other.set():\n            return rich_to_bool(op, 0)\n        return rich_to_bool(op, -1)\n\n    def issubset(self, other):\n        r\"\"\"\n        Return whether ``self`` is a subset of ``other``.\n\n        INPUT:\n\n         - ``other`` -- a finite Set\n\n        EXAMPLES::\n\n            sage: X = Set([1,3,5])\n            sage: Y = Set([0,1,2,3,5,7])\n            sage: X.issubset(Y)\n            True\n            sage: Y.issubset(X)\n            False\n            sage: X.issubset(X)\n            True\n\n        TESTS::\n\n            sage: len([Z for Z in Y.subsets() if Z.issubset(X)])\n            8\n        \"\"\"\n        if not isinstance(other, Set_object_enumerated):\n            raise NotImplementedError\n        return self.set().issubset(other.set())\n\n    def issuperset(self, other):\n        r\"\"\"\n        Return whether ``self`` is a superset of ``other``.\n\n        INPUT:\n\n         - ``other`` -- a finite Set\n\n        EXAMPLES::\n\n            sage: X = Set([1,3,5])\n            sage: Y = Set([0,1,2,3,5])\n            sage: X.issuperset(Y)\n            False\n            sage: Y.issuperset(X)\n            True\n            sage: X.issuperset(X)\n            True\n\n        TESTS::\n\n            sage: len([Z for Z in Y.subsets() if Z.issuperset(X)])\n            4\n        \"\"\"\n        if not isinstance(other, Set_object_enumerated):\n            raise NotImplementedError\n        return self.set().issuperset(other.set())\n\n    def union(self, other):\n        \"\"\"\n        Return the union of ``self`` and ``other``.\n\n        EXAMPLES::\n\n            sage: X = Set(GF(8,'c'))\n            sage: Y = Set([GF(8,'c').0, 1, 2, 3])\n            sage: X\n            {0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1}\n            sage: sorted(Y)\n            [1, 2, 3, c]\n            sage: sorted(X.union(Y), key=str)\n            [0, 1, 2, 3, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1]\n        \"\"\"\n        if not isinstance(other, Set_object_enumerated):\n            return Set_object.union(self, other)\n        return Set_object_enumerated(self.set().union(other.set()))\n\n    def intersection(self, other):\n        \"\"\"\n        Return the intersection of ``self`` and ``other``.\n\n        EXAMPLES::\n\n            sage: X = Set(GF(8,'c'))\n            sage: Y = Set([GF(8,'c').0, 1, 2, 3])\n            sage: X.intersection(Y)\n            {1, c}\n        \"\"\"\n        if not isinstance(other, Set_object_enumerated):\n            return Set_object.intersection(self, other)\n        return Set_object_enumerated(self.set().intersection(other.set()))\n\n    def difference(self, other):\n        \"\"\"\n        Return the set difference ``self - other``.\n\n        EXAMPLES::\n\n            sage: X = Set([1,2,3,4])\n            sage: Y = Set([1,2])\n            sage: X.difference(Y)\n            {3, 4}\n            sage: Z = Set(ZZ)\n            sage: W = Set([2.5, 4, 5, 6])\n            sage: W.difference(Z)\n            {2.50000000000000}\n        \"\"\"\n        if not isinstance(other, Set_object_enumerated):\n            return Set([x for x in self if x not in other])\n        return Set_object_enumerated(self.set().difference(other.set()))\n\n    def symmetric_difference(self, other):\n        \"\"\"\n        Return the symmetric difference of ``self`` and ``other``.\n\n        EXAMPLES::\n\n            sage: X = Set([1,2,3,4])\n            sage: Y = Set([1,2])\n            sage: X.symmetric_difference(Y)\n            {3, 4}\n            sage: Z = Set(ZZ)\n            sage: W = Set([2.5, 4, 5, 6])\n            sage: U = W.symmetric_difference(Z)\n            sage: 2.5 in U\n            True\n            sage: 4 in U\n            False\n            sage: V = Z.symmetric_difference(W)\n            sage: V == U\n            True\n            sage: 2.5 in V\n            True\n            sage: 6 in V\n            False\n        \"\"\"\n        if not isinstance(other, Set_object_enumerated):\n            return Set_object.symmetric_difference(self, other)\n        return Set_object_enumerated(self.set().symmetric_difference(other.set()))\n\nclass Set_object_binary(Set_object):\n    r\"\"\"\n    An abstract common base class for sets defined by a binary operation (ex.\n    :class:`Set_object_union`, :class:`Set_object_intersection`,\n    :class:`Set_object_difference`, and\n    :class:`Set_object_symmetric_difference`).\n\n    INPUT:\n\n    - ``X``, ``Y`` -- sets, the operands to ``op``\n\n    - ``op`` -- a string describing the binary operation\n\n    - ``latex_op`` -- a string used for rendering this object in LaTeX\n\n    EXAMPLES::\n\n        sage: X = Set(QQ^2)\n        sage: Y = Set(ZZ)\n        sage: from sage.sets.set import Set_object_binary\n        sage: S = Set_object_binary(X, Y, \"union\", \"\\\\cup\"); S\n        Set-theoretic union of Set of elements of Vector space of dimension 2\n         over Rational Field and Set of elements of Integer Ring\n    \"\"\"\n    def __init__(self, X, Y, op, latex_op):\n        r\"\"\"\n        Initialization.\n\n        TESTS::\n\n            sage: from sage.sets.set import Set_object_binary\n            sage: X = Set(QQ^2)\n            sage: Y = Set(ZZ)\n            sage: S = Set_object_binary(X, Y, \"union\", \"\\\\cup\")\n            sage: type(S)\n            <class 'sage.sets.set.Set_object_binary_with_category'>\n        \"\"\"\n        self._X = X\n        self._Y = Y\n        self._op = op\n        self._latex_op = latex_op\n        Set_object.__init__(self, self)\n\n    def _repr_(self):\n        r\"\"\"\n        Return a string representation of this set.\n\n        EXAMPLES::\n\n            sage: Set(ZZ).union(Set(GF(5)))\n            Set-theoretic union of Set of elements of Integer Ring and {0, 1, 2, 3, 4}\n        \"\"\"\n        return \"Set-theoretic {} of {} and {}\".format(self._op, self._X, self._Y)\n\n    def _latex_(self):\n        r\"\"\"\n        Return a latex representation of this set.\n\n        EXAMPLES::\n\n            sage: latex(Set(ZZ).union(Set(GF(5))))\n            \\Bold{Z} \\cup \\left\\{0, 1, 2, 3, 4\\right\\}\n        \"\"\"\n        return latex(self._X) + self._latex_op + latex(self._Y)\n\n    def __hash__(self):\n        \"\"\"\n        The hash value of this set.\n\n        EXAMPLES:\n\n        The hash values of equal sets are in general not equal since it is not\n        decidable whether two sets are equal::\n\n            sage: X = Set(GF(13)).intersection(Set(ZZ))\n            sage: Y = Set(ZZ).intersection(Set(GF(13)))\n            sage: hash(X) == hash(Y)\n            False\n\n        TESTS:\n\n        Test that :trac:`14432` has been resolved::\n\n            sage: S = Set(ZZ).union(Set([infinity]))\n            sage: T = Set(ZZ).union(Set([infinity]))\n            sage: hash(S) == hash(T)\n            True\n        \"\"\"\n        return hash((self._X, self._Y, self._op))\n\nclass Set_object_union(Set_object_binary):\n    \"\"\"\n    A formal union of two sets.\n    \"\"\"\n    def __init__(self, X, Y):\n        r\"\"\"\n        Initialize ``self``.\n\n        EXAMPLES::\n\n            sage: S = Set(QQ^2)\n            sage: T = Set(ZZ)\n            sage: X = S.union(T); X\n            Set-theoretic union of Set of elements of Vector space of dimension 2 over Rational Field and Set of elements of Integer Ring\n\n            sage: latex(X)\n            \\Bold{Q}^{2} \\cup \\Bold{Z}\n\n            sage: TestSuite(X).run()\n        \"\"\"\n        Set_object_binary.__init__(self, X, Y, \"union\", \"\\\\cup\")\n\n    def is_finite(self):\n        r\"\"\"\n        Return whether this set is finite.\n\n        EXAMPLES::\n\n            sage: X = Set(range(10))\n            sage: Y = Set(range(-10,0))\n            sage: Z = Set(Primes())\n            sage: X.union(Y).is_finite()\n            True\n            sage: X.union(Z).is_finite()\n            False\n        \"\"\"\n        return self._X.is_finite() and self._Y.is_finite()\n\n    def __richcmp__(self, right, op):\n        r\"\"\"\n        Try to compare ``self`` and ``right``.\n\n        .. NOTE::\n\n           Comparison is basically not implemented, or rather it could\n           say sets are not equal even though they are.  I don't know\n           how one could implement this for a generic union of sets in\n           a meaningful manner.  So be careful when using this.\n\n        EXAMPLES::\n\n            sage: Y = Set(ZZ^2).union(Set(ZZ^3))\n            sage: X = Set(ZZ^3).union(Set(ZZ^2))\n            sage: X == Y\n            True\n            sage: Y == X\n            True\n\n        This illustrates that equality testing for formal unions\n        can be misleading in general.\n\n        ::\n\n            sage: Set(ZZ).union(Set(QQ)) == Set(QQ)\n            False\n        \"\"\"\n        if not isinstance(right, Set_generic):\n            return rich_to_bool(op, -1)\n        if not isinstance(right, Set_object_union):\n            return rich_to_bool(op, -1)\n        if self._X == right._X and self._Y == right._Y or \\\n           self._X == right._Y and self._Y == right._X:\n            return rich_to_bool(op, 0)\n        return rich_to_bool(op, -1)\n\n    def __iter__(self):\n        \"\"\"\n        Return iterator over the elements of ``self``.\n\n        EXAMPLES::\n\n            sage: [x for x in Set(GF(3)).union(Set(GF(2)))]\n            [0, 1, 2, 0, 1]\n        \"\"\"\n        for x in self._X:\n            yield x\n        for y in self._Y:\n            yield y\n\n    def __contains__(self, x):\n        \"\"\"\n        Return ``True`` if ``x`` is an element of ``self``.\n\n        EXAMPLES::\n\n            sage: X = Set(GF(3)).union(Set(GF(2)))\n            sage: GF(5)(1) in X\n            False\n            sage: GF(3)(2) in X\n            True\n            sage: GF(2)(0) in X\n            True\n            sage: GF(5)(0) in X\n            False\n        \"\"\"\n        return x in self._X or x in self._Y\n\n    def cardinality(self):\n        \"\"\"\n        Return the cardinality of this set.\n\n        EXAMPLES::\n\n            sage: X = Set(GF(3)).union(Set(GF(2)))\n            sage: X\n            {0, 1, 2, 0, 1}\n            sage: X.cardinality()\n            5\n\n            sage: X = Set(GF(3)).union(Set(ZZ))\n            sage: X.cardinality()\n            +Infinity\n        \"\"\"\n        return self._X.cardinality() + self._Y.cardinality()\n\nclass Set_object_intersection(Set_object_binary):\n    \"\"\"\n    Formal intersection of two sets.\n    \"\"\"\n    def __init__(self, X, Y):\n        r\"\"\"\n        Initialize ``self``.\n\n        EXAMPLES::\n\n            sage: S = Set(QQ^2)\n            sage: T = Set(ZZ)\n            sage: X = S.intersection(T); X\n            Set-theoretic intersection of Set of elements of Vector space of dimension 2 over Rational Field and Set of elements of Integer Ring\n            sage: latex(X)\n            \\Bold{Q}^{2} \\cap \\Bold{Z}\n\n            sage: X = Set(IntegerRange(100)).intersection(Primes())\n            sage: X.is_finite()\n            True\n            sage: TestSuite(X).run()\n        \"\"\"\n        Set_object_binary.__init__(self, X, Y, \"intersection\", \"\\\\cap\")\n\n    def is_finite(self):\n        r\"\"\"\n        Return whether this set is finite.\n\n        EXAMPLES::\n\n            sage: X = Set(IntegerRange(100))\n            sage: Y = Set(ZZ)\n            sage: X.intersection(Y).is_finite()\n            True\n            sage: Y.intersection(X).is_finite()\n            True\n            sage: Y.intersection(Set(QQ)).is_finite()\n            Traceback (most recent call last):\n            ...\n            NotImplementedError\n        \"\"\"\n        if self._X.is_finite():\n            return True\n        elif self._Y.is_finite():\n            return True\n        raise NotImplementedError\n\n    def __richcmp__(self, right, op):\n        r\"\"\"\n        Try to compare ``self`` and ``right``.\n\n        .. NOTE::\n\n           Comparison is basically not implemented, or rather it could\n           say sets are not equal even though they are.  I don't know\n           how one could implement this for a generic intersection of\n           sets in a meaningful manner.  So be careful when using this.\n\n        EXAMPLES::\n\n            sage: Y = Set(ZZ).intersection(Set(QQ))\n            sage: X = Set(QQ).intersection(Set(ZZ))\n            sage: X == Y\n            True\n            sage: Y == X\n            True\n\n        This illustrates that equality testing for formal unions\n        can be misleading in general.\n\n        ::\n\n            sage: Set(ZZ).intersection(Set(QQ)) == Set(QQ)\n            False\n        \"\"\"\n        if not isinstance(right, Set_generic):\n            return rich_to_bool(op, -1)\n        if not isinstance(right, Set_object_intersection):\n            return rich_to_bool(op, -1)\n        if self._X == right._X and self._Y == right._Y or \\\n           self._X == right._Y and self._Y == right._X:\n            return rich_to_bool(op, 0)\n        return rich_to_bool(op, -1)\n\n    def __iter__(self):\n        \"\"\"\n        Return iterator through elements of ``self``.\n\n        ``self`` is a formal intersection of `X` and `Y` and this function is\n        implemented by iterating through the elements of `X` and for\n        each checking if it is in `Y`, and if yielding it.\n\n        EXAMPLES::\n\n            sage: X = Set(ZZ).intersection(Primes())\n            sage: I = X.__iter__()\n            sage: next(I)\n            2\n\n        Check that known finite intersections have finite iterators (see\n        :trac:`18159`)::\n\n            sage: P = Set(ZZ).intersection(Set(range(10,20)))\n            sage: list(P)\n            [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n        \"\"\"\n        X = self._X\n        Y = self._Y\n        if not self._X.is_finite() and self._Y.is_finite():\n            X,Y = Y,X\n        for x in X:\n            if x in Y:\n                yield x\n\n    def __contains__(self, x):\n        \"\"\"\n        Return ``True`` if ``self`` contains ``x``.\n\n        Since ``self`` is a formal intersection of `X` and `Y` this function\n        returns ``True`` if both `X` and `Y` contains ``x``.\n\n        EXAMPLES::\n\n            sage: X = Set(QQ).intersection(Set(RR))\n            sage: 5 in X\n            True\n            sage: ComplexField().0 in X\n            False\n\n        Any specific floating-point number in Sage is to finite precision,\n        hence it is rational::\n\n            sage: RR(sqrt(2)) in X\n            True\n\n        Real constants are not rational::\n\n            sage: pi in X\n            False\n        \"\"\"\n        return x in self._X and x in self._Y\n\nclass Set_object_difference(Set_object_binary):\n    \"\"\"\n    Formal difference of two sets.\n    \"\"\"\n    def __init__(self, X, Y):\n        r\"\"\"\n        Initialize ``self``.\n\n        EXAMPLES::\n\n            sage: S = Set(QQ)\n            sage: T = Set(ZZ)\n            sage: X = S.difference(T); X\n            Set-theoretic difference of Set of elements of Rational Field and Set of elements of Integer Ring\n            sage: latex(X)\n            \\Bold{Q} - \\Bold{Z}\n\n            sage: TestSuite(X).run()\n        \"\"\"\n        Set_object_binary.__init__(self, X, Y, \"difference\", \"-\")\n\n    def is_finite(self):\n        r\"\"\"\n        Return whether this set is finite.\n\n        EXAMPLES::\n\n            sage: X = Set(range(10))\n            sage: Y = Set(range(-10,5))\n            sage: Z = Set(QQ)\n            sage: X.difference(Y).is_finite()\n            True\n            sage: X.difference(Z).is_finite()\n            True\n            sage: Z.difference(X).is_finite()\n            False\n            sage: Z.difference(Set(ZZ)).is_finite()\n            Traceback (most recent call last):\n            ...\n            NotImplementedError\n        \"\"\"\n        if self._X.is_finite():\n            return True\n        elif self._Y.is_finite():\n            return False\n        raise NotImplementedError\n\n    def __richcmp__(self, right, op):\n        r\"\"\"\n        Try to compare ``self`` and ``right``.\n\n        .. NOTE::\n\n           Comparison is basically not implemented, or rather it could\n           say sets are not equal even though they are.  I don't know\n           how one could implement this for a generic intersection of\n           sets in a meaningful manner.  So be careful when using\n           this.\n\n        EXAMPLES::\n\n            sage: Y = Set(ZZ).difference(Set(QQ))\n            sage: Y == Set([])\n            False\n            sage: X = Set(QQ).difference(Set(ZZ))\n            sage: Y == X\n            False\n            sage: Z = X.difference(Set(ZZ))\n            sage: Z == X\n            False\n\n        This illustrates that equality testing for formal unions\n        can be misleading in general.\n\n        ::\n\n            sage: X == Set(QQ).difference(Set(ZZ))\n            True\n        \"\"\"\n        if not isinstance(right, Set_generic):\n            return rich_to_bool(op, -1)\n        if not isinstance(right, Set_object_difference):\n            return rich_to_bool(op, -1)\n        if self._X == right._X and self._Y == right._Y:\n            return rich_to_bool(op, 0)\n        return rich_to_bool(op, -1)\n\n    def __iter__(self):\n        \"\"\"\n        Return iterator through elements of ``self``.\n\n        ``self`` is a formal difference of `X` and `Y` and this function\n        is implemented by iterating through the elements of `X` and for\n        each checking if it is not in `Y`, and if yielding it.\n\n        EXAMPLES::\n\n            sage: X = Set(ZZ).difference(Primes())\n            sage: I = X.__iter__()\n            sage: next(I)\n            0\n            sage: next(I)\n            1\n            sage: next(I)\n            -1\n            sage: next(I)\n            -2\n            sage: next(I)\n            -3\n        \"\"\"\n        for x in self._X:\n            if x not in self._Y:\n                yield x\n\n    def __contains__(self, x):\n        \"\"\"\n        Return ``True`` if ``self`` contains ``x``.\n\n        Since ``self`` is a formal intersection of `X` and `Y` this function\n        returns ``True`` if both `X` and `Y` contains ``x``.\n\n        EXAMPLES::\n\n            sage: X = Set(QQ).difference(Set(ZZ))\n            sage: 5 in X\n            False\n            sage: ComplexField().0 in X\n            False\n            sage: sqrt(2) in X     # since sqrt(2) is not a numerical approx\n            False\n            sage: sqrt(RR(2)) in X # since sqrt(RR(2)) is a numerical approx\n            True\n            sage: 5/2 in X\n            True\n        \"\"\"\n        return x in self._X and x not in self._Y\n\nclass Set_object_symmetric_difference(Set_object_binary):\n    \"\"\"\n    Formal symmetric difference of two sets.\n    \"\"\"\n    def __init__(self, X, Y):\n        r\"\"\"\n        Initialize ``self``.\n\n        EXAMPLES::\n\n            sage: S = Set(QQ)\n            sage: T = Set(ZZ)\n            sage: X = S.symmetric_difference(T); X\n            Set-theoretic symmetric difference of Set of elements of Rational Field and Set of elements of Integer Ring\n            sage: latex(X)\n            \\Bold{Q} \\bigtriangleup \\Bold{Z}\n\n            sage: TestSuite(X).run()\n        \"\"\"\n        Set_object_binary.__init__(self, X, Y, \"symmetric difference\", \"\\\\bigtriangleup\")\n\n    def is_finite(self):\n        r\"\"\"\n        Return whether this set is finite.\n\n        EXAMPLES::\n\n            sage: X = Set(range(10))\n            sage: Y = Set(range(-10,5))\n            sage: Z = Set(QQ)\n            sage: X.symmetric_difference(Y).is_finite()\n            True\n            sage: X.symmetric_difference(Z).is_finite()\n            False\n            sage: Z.symmetric_difference(X).is_finite()\n            False\n            sage: Z.symmetric_difference(Set(ZZ)).is_finite()\n            Traceback (most recent call last):\n            ...\n            NotImplementedError\n        \"\"\"\n        if self._X.is_finite():\n            return self._Y.is_finite()\n        elif self._Y.is_finite():\n            return False\n        raise NotImplementedError\n\n    def __richcmp__(self, right, op):\n        r\"\"\"\n        Try to compare ``self`` and ``right``.\n\n        .. NOTE::\n\n           Comparison is basically not implemented, or rather it could\n           say sets are not equal even though they are.  I don't know\n           how one could implement this for a generic symmetric\n           difference of sets in a meaningful manner.  So be careful\n           when using this.\n\n        EXAMPLES::\n\n            sage: Y = Set(ZZ).symmetric_difference(Set(QQ))\n            sage: X = Set(QQ).symmetric_difference(Set(ZZ))\n            sage: X == Y\n            True\n            sage: Y == X\n            True\n\n        \"\"\"\n        if not isinstance(right, Set_generic):\n            return rich_to_bool(op, -1)\n        if not isinstance(right, Set_object_symmetric_difference):\n            return rich_to_bool(op, -1)\n        if self._X == right._X and self._Y == right._Y or \\\n           self._X == right._Y and self._Y == right._X:\n            return rich_to_bool(op, 0)\n        return rich_to_bool(op, -1)\n\n    def __iter__(self):\n        \"\"\"\n        Return iterator through elements of ``self``.\n\n        This function is implemented by first iterating through the elements\n        of `X` and  yielding it if it is not in `Y`.\n        Then it will iterate throw all the elements of `Y` and yielding it if\n        it is not in `X`.\n\n        EXAMPLES::\n\n            sage: X = Set(ZZ).symmetric_difference(Primes())\n            sage: I = X.__iter__()\n            sage: next(I)\n            0\n            sage: next(I)\n            1\n            sage: next(I)\n            -1\n            sage: next(I)\n            -2\n            sage: next(I)\n            -3\n        \"\"\"\n        for x in self._X:\n            if x not in self._Y:\n                yield x\n\n        for y in self._Y:\n            if y not in self._X:\n                yield y\n\n    def __contains__(self, x):\n        \"\"\"\n        Return ``True`` if ``self`` contains ``x``.\n\n        Since ``self`` is the formal symmetric difference of `X` and `Y`\n        this function returns ``True`` if either `X` or `Y` (but not both)\n        contains ``x``.\n\n        EXAMPLES::\n\n            sage: X = Set(QQ).symmetric_difference(Primes())\n            sage: 4 in X\n            True\n            sage: ComplexField().0 in X\n            False\n            sage: sqrt(2) in X      # since sqrt(2) is currently symbolic\n            False\n            sage: sqrt(RR(2)) in X # since sqrt(RR(2)) is currently approximated\n            True\n            sage: pi in X\n            False\n            sage: 5/2 in X\n            True\n            sage: 3 in X\n            False\n        \"\"\"\n        return (x in self._X and x not in self._Y) \\\n               or (x in self._Y and x not in self._X)\n\ndef is_Set(x):\n    \"\"\"\n    Deprecated. Use ``isinstance(x, Set_generic)`` instead.\n\n    TESTS::\n\n        sage: from sage.sets.set import is_Set\n        sage: is_Set(Primes())\n        doctest:...: DeprecationWarning: Please use isinstance(x, Set_generic)\n        See http://trac.sagemath.org/24443 for details.\n        True\n    \"\"\"\n    from sage.misc.superseded import deprecation\n    deprecation(24443, \"Please use isinstance(x, Set_generic)\")\n    return isinstance(x, Set_generic)\n", "meta": {"hexsha": "fe4d1949ca4497f13dffdfa1cc9b671376fdf462", "size": 48006, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/sets/set.py", "max_stars_repo_name": "ChamanAgrawal/sage", "max_stars_repo_head_hexsha": "5f6d56ba247b352d7d46442e88fa3a027e9f222d", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-06-02T03:16:47.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-15T10:17:19.000Z", "max_issues_repo_path": "src/sage/sets/set.py", "max_issues_repo_name": "ChamanAgrawal/sage", "max_issues_repo_head_hexsha": "5f6d56ba247b352d7d46442e88fa3a027e9f222d", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/sets/set.py", "max_forks_repo_name": "ChamanAgrawal/sage", "max_forks_repo_head_hexsha": "5f6d56ba247b352d7d46442e88fa3a027e9f222d", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-06-02T03:17:08.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-02T03:17:08.000Z", "avg_line_length": 27.8134414832, "max_line_length": 162, "alphanum_fraction": 0.4984793567, "include": true, "reason": "import sage,from sage", "num_tokens": 12475, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4455295350395727, "lm_q2_score": 0.13477590525944355, "lm_q1q2_score": 0.06004664640477739}}
{"text": "# -*- coding: utf-8 -*-\n# ---\n# jupyter:\n#   jupytext:\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.4'\n#       jupytext_version: 1.2.4\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# <div style='background-image: url(\"../share/images/header.svg\") ; padding: 0px ; background-size: cover ; border-radius: 5px ; height: 250px'>\n#     <div style=\"float: right ; margin: 50px ; padding: 20px ; background: rgba(255 , 255 , 255 , 0.7) ; width: 50% ; height: 150px\">\n#         <div style=\"position: relative ; top: 50% ; transform: translatey(-50%)\">\n#             <div style=\"font-size: xx-large ; font-weight: 900 ; color: rgba(0 , 0 , 0 , 0.8) ; line-height: 100%\">Applied Seismology</div>\n#             <div style=\"font-size: large ; padding-top: 20px ; color: rgba(0 , 0 , 0 , 0.5)\">Lab: Instrument Response</div>\n#         </div>\n#     </div>\n# </div>\n\n# Seismo-Live: http://seismo-live.org\n#\n# ##### Authors:\n# * Carl Tape ([@carltape](https://github.com/carltape))\n# * Lion Krischer ([@krischer](https://github.com/krischer))\n# ---\n\n# based on *GEOS 626: Applied Seismology from Carl Tape*\n#\n# ---\n\n# This cell does two things: \n# (1) make plots appear in the notebook and (2) creates prettier plots.\n# Make sure to execute it at least once!\n# %matplotlib inline\nimport matplotlib.pyplot as plt\nplt.style.use('ggplot')\nplt.rcParams['figure.figsize'] = 10, 5\n\n# ### L1 Instructions\n#\n# This is a Python and ObsPy version of the above mentioned lab. We will perform the same calculations and create similar plots but we will be using different services, data formats, and tools.\n#\n# It aims to teach students how to calculate, visualize and use instruments responses.\n\n# ### L2 Computing and plotting instrument response, $I(ω)$ \n\n# ##### Acquiring Data\n#\n# The first step when working with instrument data is to acquire it. Nowadays this is mostly done using the *station* web service defined by the [FDSN](http://www.fdsn.org/) (International Federation of Digital Seismograph Networks). Once you know how to use this you can use it to download data from data centers across the globe including IRIS, ORFEUS, ETH, RESIF, GEONET, and many more. Notable exceptions are most Asian countries and countries that don't freely share their data.\n\n# With ObsPy this works by first importing the FDSN `Client` class and then initializing it with the data center you want to download from. For this lab we will use data from the Geoscope project, which can be downloaded from IRIS (its \"home\" data center is the IPGP in Paris which you can also use - just replace `\"IRIS\"` with `\"IPGP\"` in the following code box - but most of you will be more familiar with IRIS).\n#\n# See the [documentation of obspy.clients.fdsn](http://docs.obspy.org/packages/obspy.clients.fdsn.html) for more details.\n\nfrom obspy.clients.fdsn import Client\n# ObsPy knows which website to connect to for many data center.\n# For others you can also pass the full URL.\nc = Client(\"IRIS\")\n\n# Station information is time dependent due to for example changed sensors, new calibrations, or other changes. It is thus important to specify the time frame for which to request response information.\n#\n# ObsPy handles absolute times with the `UTCDateTime` class. See the [documentation](http://docs.obspy.org/packages/autogen/obspy.core.utcdatetime.UTCDateTime.html) and the [tutorial](http://docs.obspy.org/tutorial/code_snippets/utc_date_time.html) for more information.\n\nimport obspy\n# Create two times which we will later use to download time series data.\nstarttime = obspy.UTCDateTime(2004, 12, 26, 0, 58, 50)\n# Create a new time object by adding 5 days to the previous ones. Time\n# differences are in seconds.\nendtime = starttime + 86400 * 5\n\n# We will use the `CAN` station which is located in Canberra, Australia, and featured in [*Park et al.* (2005, Figure 1)](http://dx.doi.org/10.1126/science.1112305). Please note that in many cases the station code is not unique and in practice the network code is also required. See the ObsPy tutorials for more details about these concepts. The `get_station()` method of the FDSN `Client` object returns station/instrument information. Once again see its [documentation](http://docs.obspy.org/packages/autogen/obspy.clients.fdsn.client.Client.get_stations.html) for more information.\n\n# This will get all stations that satisfy all constraints simultaneosly.\ninv = c.get_stations(network=\"G\", station=\"CAN\", channel=\"LHZ\", \n                     level=\"response\", \n                     starttime=starttime, endtime=endtime)\nprint(inv)\n\n# The `station` services return `StationXML` files which are the most modern and future proof data format for station and instrument information. **If possible at all: Always try to use StationXML files!**\n\n# ##### Plotting the Instrument Response\n#\n# We can now plot the instrument response with the `plot_response()` method. The `min_freq` argument determines the lowest plotted frequency - the maximum plotted frequency is always the Nyquist frequency.\n\ninv.plot_response(min_freq=0.001);\n\n# These are [Bode plots](https://en.wikipedia.org/wiki/Bode_plot) and show the amplitude $A(\\omega)$ and the phase $\\phi(\\omega)$ response where\n#\n# $$\n# I(\\omega) = A(\\omega) e^{i \\phi(\\omega)}\n# $$\n#\n# Note that the formulas use $\\omega$ but the plots show the frequency $f$ with $\\omega = 2 \\pi f$. The first variant usually simplifies notation whereas the latter one facilitates physical interpretation.\n#\n# This plot does not just show the instrument response - it shows the response of the whole recording chain from observed ground motion to actually stored data. This includes the analoge response of the actual seismometer, the analog-to-digitial converter (DAC), and possible digital filter stages.\n\n# The sampling rate of this channel is 1 sample per second ($\\Delta T$ = 1s), so the **Nyquist frequency**, which is defined as\n#\n# $$\n# f_{Nyq} = 1 / (2 \\Delta t),\n# $$\n#\n# is $f_{Nyq}$ = 0.5 Hz. The above plot does not show frequencies higher than the Nyquist frequency (the vertical dashed line) as these frequencies do not exist in the data and thus have no physical meaning.\n\n# Have a look at the details of the response information of this channel:\n\ninv[0][0][0].response\n\n# Here we see that it consists of multiple stages that convert from one unit to another. The final instrument response is the multipication (in the frequency domain) of all of these.\n#\n# **QUESTION:** What are the input and output units of the whole instrument? What does that mean physically?\n#\n# **QUESTION:** How does one conceptually remove the instrument response from recorded data?\n#\n# ##### Incomplete Responses\n#\n# You can also only plot the response of a range of stages. The plotted sensitivity in Obspy 1.0.1 is the overall sensitivity of all stages and not only the chosen ones - thus the plot looks a bit strange. This will be rectified [soon](https://github.com/obspy/obspy/issues/1368).\n\ninv[0][0][0].plot(0.001, start_stage=1, end_stage=1);\n\n# Note that the major differences (except a constant factor) are close to the Nyquist frequency - these are due to the here not plotted decimation and FIR filter stages. In many cases it is sufficient to only use Poles & Zeros information but there are stations where this is not true. As it is tedious to manually check everytime: **There is no reason to not use the full chain instrument response if it is available!**\n\n# ##### Output Units\n\n# Modern seismometers usually record the velocity of ground motion, strong motions sensor record acceleration.\n#\n# **QUESTION:** Why is that?\n#\n# The instrument response describes how incoming data (in whatever the instrument measures) it transformed into what is finally stored in a file. Restoring original ground motion requires the inversion of that process. The deconvolution of the instrument response as written for example in a StationXML file will convert data back to its original units.\n#\n# If your analysis requires other units it is best to perform the integration or differentiation during the instrument deconvolution. That deconvolution is usually performed in the frequency domain - once there integration/differentiation is almost free and the most accurate it gets.\n\n# The following plots show the instrument response $I_d(\\omega)$ from displacement, velocity $I_v(\\omega)$, and acceleration $I_a(\\omega)$.\n\nprint(\"Displacement\")\ninv.plot_response(0.001, output=\"DISP\")\nprint(\"Velocity\")\ninv.plot_response(0.001, output=\"VEL\")\nprint(\"Acceleration\")\ninv.plot_response(0.001, output=\"ACC\");\n\n#\n# Basic properties of the Fourier transform result in \n#\n# $$\n# \\begin{align}\n# X_v(\\omega) &= (i \\omega) X_d(\\omega) \\\\\n# X_a(\\omega) &= (i \\omega) X_v(\\omega)\n# \\end{align}\n# $$\n#\n# where $X_d$, $X_v$, and $X_a$ are the Fourier transforms of displacement $x_d(t)$, velocity $x_v(t)$, and acceleration $x_a(t)$.\n#\n# We also have the relationship between ground motion, instrument response, and the output form the seismometer:\n#\n# $$\n# \\begin{align}\n# x_a(t) * i_a(t) &= c(t) \\\\\n# X_a(\\omega) I_a (\\omega) &= C(\\omega) \n# \\end{align}\n# $$\n#\n# Here we have assumed that the instrument response is described with respect to acceleration. But we could alternatively consider the instrument response with respect to velocity or displacement; **the key point is that what comes out of the seismometer,** $C(\\omega)$**, is fixed.** But we can descibe the input ground motion as displacement, velocity, or acceleration. Showing all three together and omitting explicit $\\omega$ dependence, we have\n#\n# $$\n# \\begin{align}\n# C &= X_a I_a = X_v I_v = X_d I_d\\\\\n#   &= (i\\omega) X_v I_a = (i \\omega) X_d I_V = X_d I_d \\\\\n#   &= (i\\omega)^2 X_d I_a = (i \\omega) X_d I_V = X_d I_d \\\\\n# I_v &= I_d \\ (i\\omega)\\\\\n# I_a&= I_v \\ (i\\omega)\\\\\n# \\end{align}\n# $$\n#\n# It turns out that the effect of differentiation in the time domain leads to an *increase by a factor of one* in the slope of the amplitude spectrum, $|H(\\omega)|$, in log-log space, for example, by changing from $X_d(\\omega)$ to $X_v(\\omega)$. But when we are looking at the *instrument response*, the slope will *decrease by a factor of one* when changing from, say, $I_d(\\omega)$ to $I_v(\\omega)$.\n#\n# We see this in the above figure. Consider the flat segment in the velocity correction spectrum: the displacement shows a corresponding slope increase whereas the acceleration show a slope decrease.\n#\n# **QUESTION:** What is meant by a \"broadband\" seismometer?\n\n# ### L3 Deconvolve instrument response for a seismogram\n\n# We will download some data and remove its instrument response.\n#\n# The first step is to get some data - we will once again use the FDSN web services but this time also to download waveform data.\n\n# +\notime = obspy.UTCDateTime(2004, 12, 26, 0, 58, 50)\nduration = 5 * 86400\nstarttime = otime\nendtime = starttime + duration\n\nst = c.get_waveforms(network=\"G\", station=\"CAN\", location=\"\", channel=\"LH*\",\n                     starttime=starttime, endtime=endtime)\n\n# Do it once again to also get the response information of the vertical channels.\ninv = c.get_stations(network=\"G\", station=\"CAN\", location=\"\", channel=\"LH*\",\n                     starttime=starttime, endtime=endtime, level=\"response\")\n# -\n\n# We will now show what the main arrival looks like at bandpass 50-500s with and without the instrument deconvolution.\n\n# Plot the first hour - slice() will leave the original \n# data stream intact and just returns a new view on the\n# data.\nst.slice(endtime=otime + 3600).copy().taper(0.05).filter(\n    \"bandpass\", freqmin=1.0 / 500.0, freqmax=1.0 / 50.0).plot()\n\n# Now plot the same but with the instrument removed.\n# Note the copy() here as remove_response() would otherwise\n# remove the contents of the original data stream.\nst.slice(endtime=otime + 3600).copy().remove_response(\n    inventory=inv, output=\"VEL\").taper(0.05).filter(\n    \"bandpass\", freqmin=1.0 / 500.0, freqmax=1.0 / 50.0).plot()\n\n# What are the differences? What is their cause?\n\n# We will now plot the amplitude spectrum over 0.2 - 1.0 mHz to show the gravest normal mode peaks. We will only use the vertical component to simplify things.\n#\n# We will first do it without instrument correction\n\n# +\nimport numpy as np\n\ntr = st.select(component=\"Z\")[0].copy().taper(0.05)\n\n# rfft() is a varient of the FFT for real valued input.\n# The negative frequencies of a DFT for purely real valued\n# input are just the complex conjugates of the corresponding\n# positive frequencies and thus redundant.\nD = np.fft.rfft(tr.data)\n# Return the corresponding frequencies.\nfreqs = np.fft.rfftfreq(tr.stats.npts, d=tr.stats.delta)\n\nplt.plot(freqs, np.abs(D))\nplt.xlim(0.2E-3, 1.0E-3)\nplt.ylim(0, 1E7)\nplt.xlabel(\"Frequency [mHz]\")\nplt.show()\n# -\n\n# Instrument removal is, in practice, a tricky and unstable operation. Have a look at the [documentation of the remove_response() method](http://docs.obspy.org/packages/autogen/obspy.core.trace.Trace.remove_response.html) and try to understand the meaning of the various parameters and when you would want to use each.\n\n# +\n# Remember the copy()!\ntr = st.select(component=\"Z\").copy().remove_response(inventory=inv, \n                                                     output=\"DISP\")[0]\n\nD = np.fft.rfft(tr.data)\nfreqs = np.fft.rfftfreq(tr.stats.npts, d=tr.stats.delta)\n\nplt.plot(freqs, np.abs(D))\nplt.xlim(0.2E-3, 1.0E-3)\nplt.ylim(0, 5.0)\nplt.xlabel(\"Frequency [mHz]\")\nplt.show()\n# -\n\n# Are there any difference to the previous versions? If yes - what are they? Keep in mind that the previous plot is based on velocity data, whereas this one has been corrected to displacement.\n\n# We are interested in the spectrum of the data so we don't really need to use instrument corrected data to calculate the spectrum - we can just calculate the spectrum and divide by the response.\n\n# +\ntr = st.select(component=\"Z\")[0].copy().taper(0.05)\n\nD = np.fft.rfft(tr.data)\nfreqs = np.fft.rfftfreq(tr.stats.npts, d=tr.stats.delta)\n# Advanced ObsPy-foo to directly get the complex response.\nfreq_response, _ = \\\n    inv.select(channel=\"LHZ\")[0][0][0].response.get_evalresp_response(\n        tr.stats.delta, tr.stats.npts, output=\"DISP\")\n\nplt.plot(freqs, np.abs(D)/ np.abs(freq_response))\nplt.xlim(0.2E-3, 1.0E-3)\nplt.ylim(0, 35.0)\nplt.xlabel(\"Frequency [mHz]\")\nplt.show()\n# -\n\n# Note that this is quite different then the previous spectrum. **Why?** Keep in mind that we are operating far from the passband of the instrument. The following two plots as well as the\n# [documentation of the remove_response() method](http://docs.obspy.org/packages/autogen/obspy.core.trace.Trace.remove_response.html) should help you answer that question. Which alternative yields the more correct answer?\n\ninv.select(channel=\"LHZ\").plot_response(min_freq=0.0001);\n\ntr = st.select(component=\"Z\").copy().remove_response(\n    inventory=inv, output=\"DISP\", plot=True)[0]\n", "meta": {"hexsha": "95896d5a37472d4899999cbe6a1fb505fb529c6a", "size": 14944, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks/General Seismology/instrument_response.py", "max_stars_repo_name": "krischer/seismo_live_build", "max_stars_repo_head_hexsha": "e4e8e59d9bf1b020e13ac91c0707eb907b05b34f", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-07-11T10:01:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-16T14:26:03.000Z", "max_issues_repo_path": "notebooks/General Seismology/instrument_response.py", "max_issues_repo_name": "krischer/seismo_live_build", "max_issues_repo_head_hexsha": "e4e8e59d9bf1b020e13ac91c0707eb907b05b34f", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "notebooks/General Seismology/instrument_response.py", "max_forks_repo_name": "krischer/seismo_live_build", "max_forks_repo_head_hexsha": "e4e8e59d9bf1b020e13ac91c0707eb907b05b34f", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-11-11T05:05:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-12T09:36:24.000Z", "avg_line_length": 51.1780821918, "max_line_length": 584, "alphanum_fraction": 0.7256423983, "include": true, "reason": "import numpy", "num_tokens": 3837, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4263215925474903, "lm_q2_score": 0.14033624589467186, "lm_q1q2_score": 0.05982837184195271}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     formats: ipynb,py:percent\n#     text_representation:\n#       extension: .py\n#       format_name: percent\n#       format_version: '1.3'\n#       jupytext_version: 1.13.3\n#   kernelspec:\n#     display_name: tcv-x21\n#     language: python\n#     name: tcv-x21\n# ---\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# # Setting up simulations of your own\n#\n# The ultimate aim of TCV-X21 is that the validation case can be replicated by\n# other simulations, and that the experimental dataset serves as a benchmark\n# for comparing and validating turbulence simulations.\n#\n# For that, we need *you* to be able to set up simulations with a turbulence\n# code of your own.\n#\n# For this, you'll need\n#\n# 1. A turbulence code of your own\n# 2. The reference equilibrium\n# 3. Sources\n# 4. Physical parameters\n#\n# You can find data files for the experimental reference scenario in\n# `data/experimental_reference/reference_scenario`.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\n# Set up the analysis environment\n\n# %load_ext autoreload\n# %autoreload 2\n# %matplotlib inline\n\nimport numpy as np\nimport xarray as xr\nimport matplotlib.pyplot as plt\nfrom pathlib import Path\nfrom netCDF4 import Dataset\n\nimport tcvx21\nfrom tcvx21 import Quantity, test_session\n\n# Apply the custom style sheet, which makes the plots look the same\nplt.style.use(tcvx21.style_sheet_inline)\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ## The reference equilibrium\n#\n# We develop a simple lower-single-null diverted magnetic geometry as the \"reference\n# scenario\". We performed several discharges in the reference scenario to gather\n# the experimental reference dataset. Next, we performed simulations in both\n# field directions of a \"reference scenario\": TCV shot number 65402 at\n# $t=1$s. The reference scenario represents a typical discharge from the\n# experimental discharges, and it is the case modelled by the codes. Note that\n# the simulations *do not use baffles* (unlike the shot number given here).\n#\n# The reference equilibrium is available in several file-formats: including\n# `eqdsk`, `.mat` (MATLAB data file), and a labelled PARALLAX-type NetCDF.\n# We demonstrate here the use of the labelled NetCDF. Note that in the figure\n# shown here is in *normalised units*. All the spatial distances are\n# divided by $R_0 = 0.90586$m.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\n# Load the equilibrium\nequi = Dataset(\n    tcvx21.experimental_reference_dir / \"reference_scenario/reference_equilibrium.nc\"\n)\n\nfig, ax = plt.subplots()\n\n# Plot the flux surfaces\nplt.contourf(\n    equi[\"Magnetic_geometry/R\"][:],\n    equi[\"Magnetic_geometry/Z\"][:],\n    equi[\"Magnetic_geometry/psi\"][:],\n    levels=20,\n)\n\ncbar = plt.colorbar()\n\n# Plot the separatrix\nplt.contour(\n    equi[\"Magnetic_geometry/R\"][:],\n    equi[\"Magnetic_geometry/Z\"][:],\n    equi[\"Magnetic_geometry/psi\"][:],\n    levels=[equi[\"Psi_limits\"].psi_seperatrix],\n    colors=\"red\",\n)\n\n# Plot the divertor\nplt.plot(\n    equi[\"divertor_polygon/R_points\"], equi[\"divertor_polygon/Z_points\"], color=\"blue\"\n)\n\n# Highlight the magnetic axis and X-point\nR0 = equi[\"Magnetic_geometry\"].magnetic_axis_R  # in metres\nplt.scatter(\n    equi[\"Magnetic_geometry\"].magnetic_axis_R / R0,\n    equi[\"Magnetic_geometry\"].magnetic_axis_Z / R0,\n    marker=\"x\",\n    color=\"blue\",\n)\nplt.scatter(\n    equi[\"Magnetic_geometry\"].x_point_R / R0,\n    equi[\"Magnetic_geometry\"].x_point_Z / R0,\n    marker=\"x\",\n    color=\"green\",\n)\n\n# Make the plot look nice and add labels\nax.set_aspect(\"equal\")\nax.set_title(\"TCV-X21 reference equilibrium\")\nax.set_xlabel(\"$R/R_0$ normalised major radius\")\nax.set_ylabel(\"$Z/R_0$ normalised vertical position\")\n\ncbar.ax.set_ylabel(\"$\\Psi$ [Weber]\", rotation=270, labelpad=20)\n\nif test_session:\n    plt.close(\"all\")\n\n# %% [markdown]\n# The equilibrium file should give you enough information to exactly replicate\n# the magnetic field structure of the TCV-X21 reference equilibrium. To\n# construct the poloidal magnetic field from the equilibrium file, you can\n# check the methods of `tcvx21.grillix_analysis.equi_m.Equi`.\n#\n# For the toroidal magnetic field strength, we assume\n# $B_\\phi = B_{\\phi, axis}\\frac{R_0}{R}$\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nfrom tcvx21.grillix_post.components.equi_m import Equi\n\ngrillix_equi = Equi(\n    tcvx21.experimental_reference_dir / \"reference_scenario/reference_equilibrium.nc\"\n)\n\nfig, ax = plt.subplots()\n\nr_test, z_test = np.linspace(0.6, 1.3), np.linspace(-0.9, 0.9)\nplt.contourf(\n    r_test,\n    z_test,\n    np.sqrt(\n        grillix_equi.magnetic_field_r(r_test, z_test, grid=True) ** 2\n        + grillix_equi.magnetic_field_z(r_test, z_test, grid=True) ** 2\n    ),\n    levels=20,\n)\ncbar = plt.colorbar()\n\nplt.plot(\n    equi[\"divertor_polygon/R_points\"], equi[\"divertor_polygon/Z_points\"], color=\"blue\"\n)\n\nax.set_aspect(\"equal\")\nax.set_title(\"Poloidal magnetic field strength\")\nax.set_xlabel(\"$R/R_0$ normalised major radius\")\nax.set_ylabel(\"$Z/R_0$ normalised vertical position\")\n\ncbar.ax.set_ylabel(\"$B_{pol}$ [Tesla]\", rotation=270, labelpad=20)\n\nif test_session:\n    plt.close(\"all\")\n\n# %% [markdown]\n# ## Sources\n#\n# The source functions used by GRILLIX are given in `tcvx21/grillix_post/components/sources_m.py`\n#\n# ### Density source or neutrals\n#\n# The scenario is fuelled from above, away from the divertor, to try to\n# reduce the amount of neutrals ionised in the divertor.\n# We expect that the neutrals are mostly ionised just inside the confined region (this is\n# called \"low-recycling\": this doesn't mean that there is no neutral recycling,\n# just that the recycled neutrals should be primarily ionised in the confined\n# region).\n#\n# There are two ways that this could be treated.\n#\n# 1. Approximate the neutral ionisation as a confined-region source\n# 2. Self-consistently treat the neutral dynamics to determine the source rate\n#\n# For the initial evaluation we select option 1 for simplicity.\n# Nevertheless, we note that using this approximation\n# is likely our greatest source of disagreement, and are interested in\n# comparing to simulations with neutrals.\n#\n# The total particle source rate isn't known exactly. We expect that\n# most of the density source results from recycled neutrals rather than\n# from neutrals injected from the gas fuelling port (and we don't have a\n# good estimate of the gas fuelling rate anyway). As such, the\n# density source rate (or neutral pressure) must be manually adjusted (see\n# tuning the sources).\n#\n# The density source used by GRILLIX is\n#\n# $S_n = \\hat{S}_n \\exp\\left[ -(\\rho^2 - \\rho_c^2)/\\rho_w\\right]$\n#\n# where $\\hat{S}_n$ is a source rate, $\\rho_c = 0.915141$ is the source centre and\n# $\\rho_w = 0.083797$ is the source width.\n#\n# ### Temperature or power source\n#\n# The shots are Ohmically heated (resistive heating due to transformer-driven\n# current). We approximate this as a power source near the magnetic axis.\n#\n# The electron temperature source is modified to give a constant power injection. The\n# power integral is\n#\n# $ P = \\frac{3}{2}\\iiint n S_{T_e} + (T_e + T_i) S_n \\textrm{d}^3V$\n#\n# which has contributions both from the electron temperature source and from the density\n# source (since adding plasma at a certain temperature requires energy). In GRILLIX,\n# we rearrange this to find an expression for $S_{T_e}$ which gives a constant power\n# rate (where $\\hat{x} = x / x_0$ is a normalised form of $x$, with normalisation factor $x_0$)\n#\n# $S_{T_e} = T_{e0} / \\tau_0 \\left(\\frac{1}{\\hat{n}}\\hat{S}_{T_{e,core}} - \\frac{\\hat{T}_e + \\hat{T}_i}{\\hat{n}} \\hat{S}_n \\right)$\n#\n# This allows us to write\n#\n# $P = \\frac{3}{2}\\iiint n_0 \\hat{n} T_{e0} / \\tau_0 \\left(\\frac{1}{\\hat{n}}\\hat{S}_{T_{e,core}} - \\frac{\\hat{T}_e + \\hat{T}_i}{\\hat{n}} \\hat{S}_n \\right) + T_{e0}(\\hat{T}_e + \\hat{T}_i) n_0 / \\tau_0 \\hat{S}_n \\textrm{d}^3V$\n#\n# $P= \\frac{3}{2}\\frac{n_0 T_{e0}}{\\tau_0} \\iiint \\hat{S}_{T_{e,core}} - (\\hat{T}_e + \\hat{T}_i) \\hat{S}_n + (\\hat{T}_e + \\hat{T}_i) \\hat{S}_n \\textrm{d}^3V$\n#\n# $P= \\frac{3}{2}\\frac{n_0 T_{e0}}{\\tau_0} \\hat{S}_{T_{e,core}} \\iiint f_{S,Te}(R,Z) \\textrm{d}^3V$\n#\n# $P= \\frac{3}{2}\\frac{n_0 T_{e0}}{\\tau_0} \\hat{S}_{T_{e,core}} \\mathcal{V}_w$\n#\n#\n# Substituting this into the power integral gives\n# $ P = \\frac{3}{2} \\int S_{T_{e,core}} d^3V$\n#\n# Then we set\n# $S_{T_{e,core}} = 1 - \\mathcal{S}_3(\\rho, \\rho_c, \\rho_w)$\n# for $\\mathcal{S}_3$ a third-order [smoothstep](https://en.wikipedia.org/wiki/Smoothstep)\n# function, centred at $\\rho_c = 0.3$ and of width $\\rho_w =0.3$.\n#\n# The term $\\mathcal{V}_w$ is the effective weighted volume of the source, which we can\n# use to work out the required source rate.\n#\n# Note that we are only taking energy out of the electron population to compensate for the density source.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nfrom tcvx21.grillix_post import components\nfrom tcvx21.grillix_post.components.sources_m import density_source_function, smoothstep\n\nfile_path = tcvx21.test_dir / \"sample_data\"\n\ngrid = components.Grid(file_path / \"vgrid.nc\")\nnorm = components.Normalisation.initialise_from_normalisation_file(\n    file_path / \"physical_parameters.nml\"\n)\nsnaps = components.read_snaps_from_file(\n    file_path, norm, time_slice=slice(None), all_planes=True\n)\nequi = components.Equi(\n    file_path / \"TCV_ortho.nc\", file_path / \"pen_metainfo.nc\", flip_z=True\n)\n\nparameter_filepath = tcvx21.grillix_post.filepath_resolver(file_path, \"params.in\")\nparams = components.convert_params_filepaths(\n    parameter_filepath, components.read_fortran_namelist(parameter_filepath)\n)\n\nrho = equi.normalised_flux_surface_label(grid.r_s, grid.z_s)\n\ndensity_source_rate = params[\"params_srcsnk\"][\"csrcn\"]\netemp_source_rate = params[\"params_srcsnk\"][\"csrcte\"]\n\ndensity_source = density_source_function(rho, grid.districts, norm, source_strength=1.0)\ncore_source = xr.DataArray(1 - smoothstep(rho, step_centre=0.3, step_width=0.3)).where(\n    grid.districts == \"CLOSED\", 0.0\n)\n\nif test_session:\n    plt.close(\"all\")\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ### Visualising the sources\n#\n#\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nfrom tcvx21.plotting.plot_array_as_transparency_m import plot_array_as_transparency\n\nfig, ax = plt.subplots()\n\nflip_z = -1.0 if equi.flipped_z else 1.0\n\n# First, let's plot the magnetic data flux surfaces\nax.contour(grid.r_s * R0, grid.z_s * R0 * flip_z, rho, levels=20)\n\n# Plot the sources, and bring them to in front of the flux-surfaces\nim = plot_array_as_transparency(\n    ax,\n    grid.r_s * R0,\n    grid.z_s * R0 * flip_z,\n    alphas=np.flipud(density_source),\n    cmap=plt.cm.Greens,\n    intensity=0.7,\n)\nim.set_zorder(np.inf)\nim = plot_array_as_transparency(\n    ax,\n    grid.r_s * R0,\n    grid.z_s * R0 * flip_z,\n    alphas=np.flipud(core_source),\n    cmap=plt.cm.Blues,\n    intensity=0.7,\n)\nim.set_zorder(np.inf)\n\ndivertor_ = tcvx21.read_from_json(\n    tcvx21.experimental_reference_dir / \"reference_scenario/divertor_polygon.json\"\n)\nseparatrix = tcvx21.analysis.find_contours(\n    grid.r_s * R0, grid.z_s * R0, rho, level=1.0\n)[0]\n\n# Mark the separatrix\nax.plot(\n    separatrix[:, 0],\n    separatrix[:, 1] * flip_z,\n    \"C2\",\n    label=\"Separatrix\",\n    linestyle=\"--\",\n)\n# Mark the divertor\nax.plot(\n    divertor_[\"r_points\"],\n    divertor_[\"z_points\"],\n    color=\"C0\",\n    label=\"Vessel\",\n    linewidth=2.0 * plt.rcParams[\"lines.linewidth\"],\n)\n# Set the plot limits in terms of the divertor\nax.set_xlim(divertor_[\"r_points\"].min(), divertor_[\"r_points\"].max())\nax.set_ylim(divertor_[\"z_points\"].min(), divertor_[\"z_points\"].max())\nax.set_aspect(\"equal\")\n\nplt.xlabel(\"R [m]\")\nplt.ylabel(\"Z [m]\")\nplt.title(\"Source positions\")\n\nif test_session:\n    plt.close(\"all\")\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ### Tuning the sources\n#\n# Depending on the type of source that you use, you have a number of free parameters. Either you\n# will need to adjust\n#\n# * Density source rate and temperature source rate (electrons and possibly ions)\n# * Density source rate and power source rate\n#\n# For this, you can tune the sources to match the following experimental constraints\n#\n# * Separatrix density of $\\approx 6\\times 10^{18} m^{-3}$\n# * Separatrix electron temperature of $\\approx 40 eV$\n# * Total injected power of $150 kW$\n# * Power crossing the separatrix of $\\approx 120 kW$ (estimated from bolometry)\n# * Total particle recycling of (very roughly) $\\approx 3\\times 10^{31} s^{-1}$ (estimated from total out-flux to\n#   wall Langmuir probes, assuming perfect recycling).\n#\n# In GRILLIX, we set the total injected power to $150 kW$ and then tune the density source\n# to match the separatrix density. We use the same sources in both field directions.\n#\n# We can work out exactly what the required core $T_e$ source rate is, by computing the\n# $\\mathcal{V}_w$ \"effective weighted volume\" of the core source, which allows us to then\n# find the source rate as\n#\n# $\\hat{S}_{T_e}= P / \\left(\\frac{3}{2}\\frac{n_0 T_0}{\\tau_0} \\mathcal{V}_w\\right)$\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nfrom tcvx21.grillix_post.observables.integrations_m import (\n    axisymmetric_cylindrical_integration,\n)\nfrom tcvx21.grillix_post.components.sources_m import core_temperature_source_function\nfrom tcvx21 import Dimensionless\n\ncore_source_volume = axisymmetric_cylindrical_integration(\n    grid,\n    norm,\n    core_temperature_source_function(\n        rho,\n        grid.districts,\n        norm,\n        source_strength=1.0,\n        source_centre=0.3,\n        source_width=0.3,\n    ).assign_attrs(norm=Dimensionless),\n)\n\ndesired_power = Quantity(150, \"kilowatt\")\nprint(f\"Effective weighted core source volume: {core_source_volume}\")\nprint(f\"Required source rate: {(desired_power / core_source_volume).to('MW m^-3')}\")\nprint(\n    f\"Dimensionless source rate: {(desired_power / (1.5 * core_source_volume * norm.Te0 * norm.n0 / norm.tau_0)).to('')}\"\n)\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ## Physical parameters\n#\n# In turbulence simulations, usually you'll convert to dimensionless quantities, such that all\n# modelled equations are in terms of unitless quantities. The normalisation factors can be\n# computed from physical parameters of the system.\n#\n# The codes do not fix the profiles, so the exact choice of the normalisation factors isn't so\n# important. The file `data/experimental_reference/reference_scenario/physical_parameters.nml` contains\n# the following physical parameters (in Fortran namelist format)\n#\n# ```\n# &physical_parameters\n#     case_name = TCV_65402\n#     # # # ! Magnetic field normalisation, usually taken on axis, in Tesla\n#     B0 = 0.929\n#     # # # ! Electron temperature normalisation, in electron-volts\n#     Te0 = 41.3\n#     # # # ! Ion temperature normalisation, in electron-volts\n#     Ti0 = 41.3\n#     # # # ! Density normalisation, in particles-per-cubic-metres\n#     n0 = 1E19\n#     # # # ! Major radius, in metres\n#     R0 = 0.906\n#     # # # ! Ion mass, in amu\n#     Mi = 2\n#     # # # ! Ion charge, in e\n#     Z = 1\n#     # # # ! Ion effective charge, in e\n#     Z_eff = 1.5\n# /\n# ```\n#\n# In GRILLIX, we use these physical parameters to calculate normalisation factors (using the excellent `pint`\n# unit handling library). You can see the calculation and definition of the terms in\n# `tcvx21/grillix_post/components/normalisation_m.py`.\n#\n# You'll need to do this for your own code, but this might provide a helpful starting point.\n#\n# Of the normalisation parameters, the reference ion drift scale is important, since\n# we set our grid resolution in terms of it.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nprint(norm)\nprint(f\"Reference ion drift scale is {norm.rho_s0.to('mm'):3.2}\")\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ### Core profiles\n#\n# You might also need core profiles, such as for setting up initial condition.\n#\n# Since these were not included in the analysis, these haven't been checked as\n# thoroughly as the edge profiles, but they still might be helpful.\n#\n# Note that ion temperature in forward field is not available.\n\n# %% jupyter={\"outputs_hidden\": false} pycharm={\"name\": \"#%%\\n\"}\nplt.style.use(tcvx21.style_sheet)\ncore_profiles = tcvx21.read_struct_from_file(\n    tcvx21.experimental_reference_dir / \"reference_scenario/dataset_TCV_CORE.mat\"\n)\n\n\ndef plot_from_matlab(data, label):\n    r, r_units, val, err, units = [\n        data[key] for key in [\"r\", \"r_units\", \"val\", \"err\", \"val_units\"]\n    ]\n\n    r = Quantity(r, r_units.lstrip(\"[\").rstrip(\"]\"))\n    val = Quantity(val, units.lstrip(\"[\").rstrip(\"]\"))\n    err = Quantity(err, units.lstrip(\"[\").rstrip(\"]\"))\n\n    plt.errorbar(r, val, err, label=label)\n    plt.xlabel(f\"$R^u - R^u_{{sep}}$ [{r.units}]\")\n    plt.ylabel(f\"{val.units}\")\n\n\nfig, ax = plt.subplots()\nplot_from_matlab(core_profiles[\"Forw\"][\"ne\"], \"n forward\")\nplot_from_matlab(core_profiles[\"Rev\"][\"ne\"], \"n reversed\")\nplt.title(\"Core density\")\nplt.legend()\n\nfig, ax = plt.subplots()\nplot_from_matlab(core_profiles[\"Forw\"][\"Te\"], \"$T_e$ forward\")\nplot_from_matlab(core_profiles[\"Rev\"][\"Te\"], \"$T_e$ reversed\")\nplot_from_matlab(core_profiles[\"Rev\"][\"Ti\"], \"$T_i$ reversed\")\nplt.title(\"Core temperatures\")\nplt.legend()\n\nif test_session:\n    plt.close(\"all\")\n\n# %% [markdown] pycharm={\"name\": \"#%% md\\n\"}\n# ## Conclusion\n#\n# Hopefully, this is enough for you to start a simulation of\n# your own. If not, let us know via issues, and we'll\n# extend the documentation and data accordingly.\n#\n# To post-process and compare to TCV-x21, you'll need to extract the data at a\n# series of measurement positions. We do this in `simulation_postprocessing.ipynb`.\n#\n#\n", "meta": {"hexsha": "f259b4ebcb65c41181ec6832c189c26a08a5b191", "size": 17679, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks/simulation_setup.py", "max_stars_repo_name": "dsoliveir/TCV-X21", "max_stars_repo_head_hexsha": "784c55adb33417e21a6736e2504a3895a9348dbe", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-12-13T11:52:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-13T11:52:39.000Z", "max_issues_repo_path": "notebooks/simulation_setup.py", "max_issues_repo_name": "dsoliveir/TCV-X21", "max_issues_repo_head_hexsha": "784c55adb33417e21a6736e2504a3895a9348dbe", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-12-18T17:18:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-26T09:23:23.000Z", "max_forks_repo_path": "notebooks/simulation_setup.py", "max_forks_repo_name": "dsoliveir/TCV-X21", "max_forks_repo_head_hexsha": "784c55adb33417e21a6736e2504a3895a9348dbe", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-12-13T12:56:09.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T20:30:28.000Z", "avg_line_length": 34.261627907, "max_line_length": 224, "alphanum_fraction": 0.7068838735, "include": true, "reason": "import numpy", "num_tokens": 5051, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41489884579676883, "lm_q2_score": 0.14414884751767365, "lm_q1q2_score": 0.059807190458017224}}
{"text": "\"\"\"\nSchnyder's Algorithm for straight-line planar embeddings\n\nA module for computing the (x,y) coordinates for a straight-line planar\nembedding of any connected planar graph with at least three vertices.  Uses\nWalter Schnyder's Algorithm from [Sch1990]_.\n\nAUTHORS:\n\n- Jonathan Bober, Emily Kirkman (2008-02-09) --  initial version\n\"\"\"\n# ****************************************************************************\n#      Copyright (C) 2008 Jonathan Bober and Emily Kirkman\n#\n# Distributed  under  the  terms  of  the  GNU  General  Public  License (GPL)\n#                         https://www.gnu.org/licenses/\n# ****************************************************************************\nfrom __future__ import absolute_import\n\nfrom sage.sets.set import Set\nfrom .all import DiGraph\n\n\ndef _triangulate(g, comb_emb):\n    \"\"\"\n    Helper function to schnyder method for computing coordinates in the plane to\n    plot a planar graph with no edge crossings.\n\n    Given a connected graph g with at least 3 vertices and a planar combinatorial\n    embedding comb_emb of g, modify g in place to form a graph whose faces are\n    all triangles, and return the set of newly created edges. Also ``comb_emb``\n    is updated in place.\n\n    The simple way to triangulate a face is to just pick a vertex and draw\n    an edge from that vertex to every other vertex in the face. Think that this\n    might ultimately result in graphs that don't look very nice when we draw them\n    so we have decided on a different strategy.  After handling special cases,\n    we add an edge to connect every third vertex on each face.  If this edge is\n    a repeat, we keep the first edge of the face and retry the process at the next\n    edge in the face list.  (By removing the special cases we guarantee that this\n    method will work on one of these attempts.)\n\n    INPUT:\n\n    - g -- the graph to triangulate\n    - ``comb_emb`` -- a planar combinatorial embedding of g\n\n    OUTPUT:\n\n    A list of edges that are added to the graph (in place)\n\n    EXAMPLES::\n\n        sage: from sage.graphs.schnyder import _triangulate\n        sage: g = Graph(graphs.CycleGraph(4))\n        sage: g.is_planar(set_embedding=True)\n        True\n        sage: _triangulate(g, g._embedding)\n        [(2, 0), (1, 3)]\n\n        sage: g = graphs.PathGraph(3)\n        sage: g.is_planar(set_embedding=True)\n        True\n        sage: new_edges = _triangulate(g, g._embedding)\n        sage: [sorted(e) for e in new_edges]\n        [[0, 2]]\n    \"\"\"\n    # first make sure that the graph has at least 3 vertices, and that it is connected\n    if g.order() < 3:\n        raise ValueError(\"A Graph with less than 3 vertices doesn't have any triangulation.\")\n    if not g.is_connected():\n        raise NotImplementedError(\"_triangulate() only knows how to handle connected graphs.\")\n\n    # At this point we know that the graph is connected, has at least 3\n    # vertices. This is where the real work starts.\n\n    faces = g.faces(comb_emb)\n    # We start by finding all of the faces of this embedding.\n\n    edges_added = []   # The list of edges that we add to the graph.\n    # This will be returned at the end.\n\n    for face in faces:\n        new_face = []\n        if len(face) < 3:\n            raise RuntimeError('Triangulate method created face %s with < 3 edges.' % face)\n        if len(face) == 3:\n            continue  # This face is already triangulated\n        elif len(face) == 4:  # In this special case just add diagonal edge to square\n            u, v, w, x = (e[0] for e in face)\n            if w == u or g.has_edge(w,u):\n                u, v, w, x = v, w, x, u\n            new_face = (w, u)\n            comb_emb[w].insert(comb_emb[w].index(x), u)\n            comb_emb[u].insert(comb_emb[u].index(v), w)\n            g.add_edge(new_face)\n            edges_added.append(new_face)\n        else:\n            N = len(face)\n            i = 0\n            while i < N - 1:\n                new_edge = (face[i + 1][1], face[i][0])  # new_edge is from third vertex in face to first\n                if g.has_edge(new_edge) or new_edge[0] == new_edge[1]:  # check for repeats\n                    new_face.append(face[i])  # if repeated, keep first edge in face instead\n                    if i == N - 2:   # if we are two from the end, found a triangle already\n                        break\n                    i += 1\n                    continue\n\n                g.add_edge(new_edge)\n                edges_added.append(new_edge)\n                comb_emb[new_edge[0]].insert(comb_emb[new_edge[0]].index((face + new_face)[i + 2][1]), new_edge[1])\n                comb_emb[new_edge[1]].insert(comb_emb[new_edge[1]].index(face[i][1]), new_edge[0])\n                new_face.append((new_edge[1], new_edge[0]))\n                i += 2\n            if i != N:\n                new_face.append(face[-1])\n            faces.append(new_face)\n\n    return edges_added\n\n\ndef _normal_label(g, comb_emb, external_face):\n    r\"\"\"\n    Helper function to schnyder method for computing coordinates in\n    the plane to plot a planar graph with no edge crossings.\n\n    Constructs a normal labelling of a triangular graph g, given the\n    planar combinatorial embedding of g and a designated external\n    face.  Returns labels dictionary.  The normal label is constructed\n    by first contracting the graph down to its external face, then\n    expanding the graph back to the original while simultaneously\n    adding angle labels.\n\n    INPUT:\n\n    - g -- the graph to find the normal labeling of (g must be triangulated)\n    - ``comb_emb`` -- a planar combinatorial embedding of g\n    - ``external_face`` -- the list of three edges in the external face of g\n\n    OUTPUT:\n\n    x -- tuple with entries\n\n        x[0] = dict of dicts of normal labeling for each vertex of g and each\n        adjacent neighbors u,v (u < v) of vertex:\n\n        { vertex : { (u,v): angel_label } }\n\n        x[1] = (v1,v2,v3) tuple of the three vertices of the external face.\n\n    EXAMPLES::\n\n        sage: from sage.graphs.schnyder import _triangulate, _normal_label, _realizer\n        sage: g = Graph(graphs.CycleGraph(7))\n        sage: g.is_planar(set_embedding=True)\n        True\n        sage: faces = g.faces(g._embedding)\n        sage: _triangulate(g, g._embedding)\n        [(2, 0), (4, 2), (6, 4), (1, 3), (6, 1), (3, 5), (4, 0), (6, 3)]\n        sage: tn = _normal_label(g, g._embedding, faces[0])\n        sage: _realizer(g, tn)\n        ({0: [<sage.graphs.schnyder.TreeNode object at ...>]},\n         (1, 0, 2))\n    \"\"\"\n    contracted = []\n    contractible = []\n\n    labels = {}\n\n    # For now we will not take the order of the outer face into account.\n    # We will correct this in the end of this function.\n    external_vertices = sorted([external_face[0][0],\n                                external_face[1][0],\n                                external_face[2][0]])\n    v1, v2, v3 = external_vertices\n    v1_neighbors = Set(g.neighbors(v1))\n\n    neighbor_count = {}\n    for v in g.vertices():\n        neighbor_count[v] = 0\n    for v in g.neighbors(v1):\n        neighbor_count[v] = len(v1_neighbors.intersection(Set(g.neighbors(v))))\n\n    for v in v1_neighbors:\n        if v in [v1, v2, v3]:\n            continue\n        if neighbor_count[v] == 2:\n            contractible.append(v)\n\n    # contraction phase:\n\n    while g.order() > 3:\n        try:\n            v = contractible.pop()\n        except Exception:\n            raise RuntimeError('Contractible list is empty but graph still has %d vertices.  (Expected 3.)' % g.order())\n\n            break\n        # going to contract v\n        v_neighbors = Set(g.neighbors(v))\n        contracted.append((v, v_neighbors,\n                           v_neighbors - v1_neighbors - Set([v1])))\n        g.delete_vertex(v)\n        v1_neighbors -= Set([v])\n        for w in v_neighbors - v1_neighbors - Set([v1]):\n            # adding edge (v1, w)\n            g.add_edge((v1, w))\n        if g.order() == 3:\n            break\n        v1_neighbors += v_neighbors - Set([v1])\n        contractible = []\n        for w in g.neighbors(v1):\n            if (len(v1_neighbors.intersection(Set(g.neighbors(w)))) == 2\n                    and w not in [v1, v2, v3]):\n                contractible.append(w)\n\n    # expansion phase:\n\n    v1, v2, v3 = g.vertices()  # always in sorted order\n\n    labels[v1] = {(v2, v3): 1}\n    labels[v2] = {(v1, v3): 2}\n    labels[v3] = {(v1, v2): 3}\n\n    while len(contracted):\n        v, new_neighbors, neighbors_to_delete = contracted.pop()\n        # going to add back vertex v\n        labels[v] = {}\n\n        for w in neighbors_to_delete:\n            g.delete_edge((v1, w))\n\n        if len(neighbors_to_delete) == 0:\n            # we are adding v into the face new_neighbors\n            w1, w2, w3 = sorted(new_neighbors)\n\n            labels[v] = {(w1, w2): labels[w3].pop((w1, w2)),\n                         (w2, w3): labels[w1].pop((w2, w3)),\n                         (w1, w3): labels[w2].pop((w1, w3))}\n            labels[w1][tuple(sorted((w2, v)))] = labels[v][(w2, w3)]\n            labels[w1][tuple(sorted((w3, v)))] = labels[v][(w2, w3)]\n\n            labels[w2][tuple(sorted((w1, v)))] = labels[v][(w1, w3)]\n            labels[w2][tuple(sorted((w3, v)))] = labels[v][(w1, w3)]\n\n            labels[w3][tuple(sorted((w1, v)))] = labels[v][(w1, w2)]\n            labels[w3][tuple(sorted((w2, v)))] = labels[v][(w1, w2)]\n        else:\n            new_neighbors_set = Set(new_neighbors)\n            angles_out_of_v1 = set()\n            vertices_in_order = []\n            l = []\n            for angle in labels[v1].keys():\n                if len(Set(angle).intersection(new_neighbors_set)) == 2:\n                    angles_out_of_v1.add(angle)\n                    l = l + list(angle)\n            # find a unique element in l\n            l.sort()\n            i = 0\n            while i < len(l):\n                if l[i] == l[i + 1]:\n                    i += 2\n                else:\n                    break\n\n            angle_set = Set(angles_out_of_v1)\n\n            vertices_in_order.append(l[i])\n            while len(angles_out_of_v1) > 0:\n                for angle in angles_out_of_v1:\n                    if vertices_in_order[-1] in angle:\n                        break\n                if angle[0] == vertices_in_order[-1]:\n                    vertices_in_order.append(angle[1])\n                else:\n                    vertices_in_order.append(angle[0])\n                angles_out_of_v1.remove(angle)\n\n            w = vertices_in_order\n\n            # is w[0] a 2 or a 3?\n            top_label = labels[w[0]][tuple(sorted((v1, w[1])))]\n            if top_label == 3:\n                bottom_label = 2\n            else:\n                bottom_label = 3\n            i = 0\n            while i < len(w) - 1:\n                labels[v][tuple(sorted((w[i], w[i + 1])))] = 1\n                labels[w[i]][tuple(sorted((w[i + 1], v)))] = top_label\n                labels[w[i + 1]][tuple(sorted((w[i], v)))] = bottom_label\n                i += 1\n\n            labels[v][tuple(sorted((v1, w[0])))] = bottom_label\n            labels[v][tuple(sorted((v1, w[-1])))] = top_label\n\n            labels[w[0]][tuple(sorted((v1, v)))] = top_label\n            labels[w[-1]][tuple(sorted((v1, v)))] = bottom_label\n            labels[v1][tuple(sorted((w[0], v)))] = 1\n            labels[v1][tuple(sorted((w[-1], v)))] = 1\n\n            # delete all the extra labels\n\n            for angle in angle_set:\n                labels[v1].pop(angle)\n\n            labels[w[0]].pop(tuple(sorted((v1, w[1]))))\n            labels[w[-1]].pop(tuple(sorted((v1, w[-2]))))\n\n            i = 1\n            while i < len(w) - 1:\n                labels[w[i]].pop(tuple(sorted((v1, w[i + 1]))))\n                labels[w[i]].pop(tuple(sorted((v1, w[i - 1]))))\n                i += 1\n\n        for w in new_neighbors:\n            g.add_edge((v, w))\n\n    # Up to this point we did not take the order of the external face into\n    # account. Since the combinatorial embedding of a triangulation is unique up\n    # to the choice of the outer face and reflection, this might lead to a\n    # reflection of the Schnyder drawing resulting from this labeling which is\n    # not conformal with comb_emb any longer. Therefore, we might have to swap\n    # the labels 1 and 2.\n    if (v1, v2) in external_face:\n        for u in labels:\n            for v, w in labels[u]:\n                if labels[u][v, w] == 1:\n                    labels[u][v, w] = 2\n                elif labels[u][v, w] == 2:\n                    labels[u][v, w] = 1\n        v1, v2 = v2, v1\n\n    return labels, (v1, v2, v3)\n\n\ndef _realizer(g, x, example=False):\n    \"\"\"\n    Given a triangulated graph g and a normal labeling constructs the\n    realizer and returns a dictionary of three trees determined by the\n    realizer, each spanning all interior vertices and rooted at one of\n    the three external vertices.\n\n    A realizer is a directed graph with edge labels that span all interior\n    vertices from each external vertex.  It is determined by giving direction\n    to the edges that have the same angle label on both sides at a vertex.\n    (Thus the direction actually points to the parent in the tree.)  The\n    edge label is set as whatever the matching angle label is.  Then from\n    any interior vertex, following the directed edges by label will\n    give a path to each of the three external vertices.\n\n    INPUT:\n\n    - g -- the graph to compute the realizer of\n    - x -- tuple with entries\n\n        x[0] = dict of dicts representing a normal labeling of g.  For\n        each vertex of g and each adjacent neighbors u,v (u < v) of\n        vertex:  { vertex : { (u,v): angle_label } }\n\n        x[1] = (v1, v2, v3) tuple of the three external vertices (also\n        the roots of each tree)\n\n    OUTPUT:\n\n    - x -- tuple with entries\n\n        x[0] = dict of lists of TreeNodes:\n\n        { root_vertex : [ list of all TreeNodes under root_vertex ] }\n\n        x[1] = (v1,v2,v3) tuple of the three external vertices (also the\n        roots of each tree)\n\n    EXAMPLES::\n\n        sage: from sage.graphs.schnyder import _triangulate, _normal_label, _realizer\n        sage: g = Graph(graphs.CycleGraph(7))\n        sage: g.is_planar(set_embedding=True)\n        True\n        sage: faces = g.faces(g._embedding)\n        sage: _triangulate(g, g._embedding)\n        [(2, 0), (4, 2), (6, 4), (1, 3), (6, 1), (3, 5), (4, 0), (6, 3)]\n        sage: tn = _normal_label(g, g._embedding, faces[0])\n        sage: _realizer(g, tn)\n        ({0: [<sage.graphs.schnyder.TreeNode object at ...>]},\n         (1, 0, 2))\n\n    \"\"\"\n    normal_labeling, (v1, v2, v3) = x\n    realizer = DiGraph()\n\n    tree_nodes = {}\n    for v in g:\n        tree_nodes[v] = [TreeNode(label=v, children=[]),\n                         TreeNode(label=v, children=[]),\n                         TreeNode(label=v, children=[])]\n\n    for v in g:\n        ones = []\n        twos = []\n        threes = []\n        l = [ones, twos, threes]\n        for angle, value in normal_labeling[v].items():\n            l[value - 1] += list(angle)\n\n        ones.sort()\n        twos.sort()\n        threes.sort()\n\n        i = 0\n        while i < len(ones) - 1:\n            if ones[i] == ones[i + 1]:\n                realizer.add_edge((ones[i], v), label=1)\n                tree_nodes[v][0].append_child(tree_nodes[ones[i]][0])\n                i += 1\n            i += 1\n        i = 0\n        while i < len(twos) - 1:\n            if twos[i] == twos[i + 1]:\n                realizer.add_edge((twos[i], v), label=2)\n                tree_nodes[v][1].append_child(tree_nodes[twos[i]][1])\n                i += 1\n            i += 1\n        i = 0\n        while i < len(threes) - 1:\n            if threes[i] == threes[i + 1]:\n                realizer.add_edge((threes[i], v), label=3)\n                tree_nodes[v][2].append_child(tree_nodes[threes[i]][2])\n                i += 1\n            i += 1\n\n    _compute_coordinates(realizer, (tree_nodes, (v1, v2, v3)))\n\n    if example:\n        realizer.show(talk=True, edge_labels=True)\n\n    return tree_nodes, (v1, v2, v3)\n\n\ndef _compute_coordinates(g, x):\n    r\"\"\"\n    Given a triangulated graph g with a dict of trees given by the\n    realizer and tuple of the external vertices, we compute the\n    coordinates of a planar geometric embedding in the grid.\n\n    The coordinates will be set to the ``_pos`` attribute of g.\n\n    INPUT:\n\n    - g -- the graph to compute the coordinates of\n    - x -- tuple with entries\n\n        x[0] = dict of tree nodes for the three trees with each external\n        vertex as root:\n\n        { root_vertex : [ list of all TreeNodes under root_vertex ] }\n\n        x[1] = (v1, v2, v3) tuple of the three external vertices (also\n        the roots of each tree)\n\n    EXAMPLES::\n\n        sage: from sage.graphs.schnyder import _triangulate, _normal_label, _realizer, _compute_coordinates\n        sage: g = Graph(graphs.CycleGraph(7))\n        sage: g.is_planar(set_embedding=True)\n        True\n        sage: faces = g.faces(g._embedding)\n        sage: _triangulate(g, g._embedding)\n        [(2, 0), (4, 2), (6, 4), (1, 3), (6, 1), (3, 5), (4, 0), (6, 3)]\n        sage: tn = _normal_label(g, g._embedding, faces[0])\n        sage: r = _realizer(g, tn)\n        sage: _compute_coordinates(g,r)\n        sage: g.get_pos()\n        {0: [0, 5], 1: [5, 1], 2: [1, 0], 3: [4, 1], 4: [1, 1], 5: [2, 2], 6: [1, 4]}\n    \"\"\"\n\n    tree_nodes, (v1, v2, v3) = x\n    # find the roots of each tree:\n    t1, t2, t3 = tree_nodes[v1][0], tree_nodes[v2][1], tree_nodes[v3][2]\n\n    # Compute the number of descendants and depth of each node in\n    # each tree.\n    t1.compute_number_of_descendants()\n    t2.compute_number_of_descendants()\n    t3.compute_number_of_descendants()\n\n    t1.compute_depth_of_self_and_children()\n    t2.compute_depth_of_self_and_children()\n    t3.compute_depth_of_self_and_children()\n\n    coordinates = {}  # the dict to pass to g.set_pos()\n\n    # Setting coordinates for external vertices\n    coordinates[t1.label] = [g.order() - 2, 1]\n    coordinates[t2.label] = [0, g.order() - 2]\n    coordinates[t3.label] = [1, 0]\n\n    for v in g.vertices():\n        if v not in [t1.label, t2.label, t3.label]:\n            # Computing coordinates for v\n            r = list((0, 0, 0))\n\n            for i in [0, 1, 2]:\n                # Computing size of region i:\n\n                # Tracing up tree (i + 1) % 3\n                p = tree_nodes[v][(i + 1) % 3]\n                while p is not None:\n                    q = tree_nodes[p.label][i].number_of_descendants\n                    # Adding number of descendants from Tree i nodes with\n                    # labels on path up tree (i + 1) % 3\n                    r[i] += q\n                    p = p.parent\n\n                # Tracing up tree (i - 1) % 3\n                p = tree_nodes[v][(i - 1) % 3]\n                while p is not None:\n                    q = tree_nodes[p.label][i].number_of_descendants\n                    # Adding number of descendants from Tree i nodes with\n                    # labels on path up tree (i - 1) % 3\n                    r[i] += q\n                    p = p.parent\n\n                q = tree_nodes[v][i].number_of_descendants\n                # Subtracting\n                r[i] -= q\n\n                # Subtracting\n                q = tree_nodes[v][(i - 1) % 3].depth\n                r[i] -= q\n\n            if sum(r) != g.order() - 1:\n                raise RuntimeError(\"Computing coordinates failed: vertex %s's coordinates sum to %s.  Expected %s\" % (v, sum(r), g.order() - 1))\n\n            coordinates[v] = r[:-1]\n\n    g.set_pos(coordinates)  # Setting _pos attribute to store coordinates\n\n\nclass TreeNode(object):\n    \"\"\"\n    A class to represent each node in the trees used by ``_realizer`` and\n    ``_compute_coordinates`` when finding a planar geometric embedding in\n    the grid.\n\n    Each tree node is doubly linked to its parent and children.\n\n    INPUT:\n\n    - ``parent`` -- the parent TreeNode of ``self``\n    - ``children`` -- a list of TreeNode children of ``self``\n    - ``label`` -- the associated realizer vertex label\n\n    EXAMPLES::\n\n        sage: from sage.graphs.schnyder import TreeNode\n        sage: tn = TreeNode(label=5)\n        sage: tn2 = TreeNode(label=2,parent=tn)\n        sage: tn3 = TreeNode(label=3)\n        sage: tn.append_child(tn3)\n        sage: tn.compute_number_of_descendants()\n        2\n        sage: tn.number_of_descendants\n        2\n        sage: tn3.number_of_descendants\n        1\n        sage: tn.compute_depth_of_self_and_children()\n        sage: tn3.depth\n        2\n    \"\"\"\n    def __init__(self, parent=None, children=None, label=None):\n        \"\"\"\n        INPUT:\n\n        - ``parent`` -- the parent TreeNode of ``self``\n        - ``children`` -- a list of TreeNode children of ``self``\n        - ``label`` -- the associated realizer vertex label\n\n        EXAMPLES::\n\n            sage: from sage.graphs.schnyder import TreeNode\n            sage: tn = TreeNode(label=5)\n            sage: tn2 = TreeNode(label=2,parent=tn)\n            sage: tn3 = TreeNode(label=3)\n            sage: tn.append_child(tn3)\n            sage: tn.compute_number_of_descendants()\n            2\n            sage: tn.number_of_descendants\n            2\n            sage: tn3.number_of_descendants\n            1\n            sage: tn.compute_depth_of_self_and_children()\n            sage: tn3.depth\n            2\n        \"\"\"\n        if children is None:\n            children = []\n        self.parent = parent\n        self.children = children\n        self.label = label\n        self.number_of_descendants = 1\n\n    def compute_number_of_descendants(self):\n        \"\"\"\n        Computes the number of descendants of self and all descendants.\n\n        For each TreeNode, sets result as attribute self.number_of_descendants\n\n        EXAMPLES::\n\n            sage: from sage.graphs.schnyder import TreeNode\n            sage: tn = TreeNode(label=5)\n            sage: tn2 = TreeNode(label=2,parent=tn)\n            sage: tn3 = TreeNode(label=3)\n            sage: tn.append_child(tn3)\n            sage: tn.compute_number_of_descendants()\n            2\n            sage: tn.number_of_descendants\n            2\n            sage: tn3.number_of_descendants\n            1\n            sage: tn.compute_depth_of_self_and_children()\n            sage: tn3.depth\n            2\n\n        \"\"\"\n        n = 1\n        for child in self.children:\n            n += child.compute_number_of_descendants()\n        self.number_of_descendants = n\n        return n\n\n    def compute_depth_of_self_and_children(self):\n        \"\"\"\n        Computes the depth of self and all descendants.\n\n        For each TreeNode, sets result as attribute self.depth\n\n        EXAMPLES::\n\n            sage: from sage.graphs.schnyder import TreeNode\n            sage: tn = TreeNode(label=5)\n            sage: tn2 = TreeNode(label=2,parent=tn)\n            sage: tn3 = TreeNode(label=3)\n            sage: tn.append_child(tn3)\n            sage: tn.compute_number_of_descendants()\n            2\n            sage: tn.number_of_descendants\n            2\n            sage: tn3.number_of_descendants\n            1\n            sage: tn.compute_depth_of_self_and_children()\n            sage: tn3.depth\n            2\n        \"\"\"\n        if self.parent is None:\n            self.depth = 1\n        else:\n            self.depth = self.parent.depth + 1\n        for child in self.children:\n            child.compute_depth_of_self_and_children()\n\n    def append_child(self, child):\n        \"\"\"\n        Add a child to list of children.\n\n        EXAMPLES::\n\n            sage: from sage.graphs.schnyder import TreeNode\n            sage: tn = TreeNode(label=5)\n            sage: tn2 = TreeNode(label=2,parent=tn)\n            sage: tn3 = TreeNode(label=3)\n            sage: tn.append_child(tn3)\n            sage: tn.compute_number_of_descendants()\n            2\n            sage: tn.number_of_descendants\n            2\n            sage: tn3.number_of_descendants\n            1\n            sage: tn.compute_depth_of_self_and_children()\n            sage: tn3.depth\n            2\n        \"\"\"\n        if child in self.children:\n            return\n        self.children.append(child)\n        child.parent = self\n\n\ndef minimal_schnyder_wood(graph, root_edge=None, minimal=True, check=True):\n    \"\"\"\n    Return the minimal Schnyder wood of a planar rooted triangulation.\n\n    INPUT:\n\n    - graph -- a planar triangulation, given by a graph with an embedding.\n\n    - root_edge -- a pair of vertices (default is from ``-1`` to ``-2``)\n      The third boundary vertex is then determined using the orientation and\n      will be labelled ``-3``.\n\n    - minimal -- boolean (default ``True``), whether to return a\n      minimal or a maximal Schnyder wood.\n\n    - check -- boolean (default ``True``), whether to check if the input\n      is a planar triangulation\n\n    OUTPUT:\n\n    A planar graph, with edges oriented and colored. The three outer\n    edges of the initial graph are removed. For the three outer vertices the\n    list of the neighbors stored in the combinatorial embedding is in the order\n    of the incident edges between the two incident (and removed) outer edges,\n    and not a cyclic shift of it.\n\n    The algorithm is taken from [Bre2000]_ (section 4.2).\n\n    EXAMPLES::\n\n        sage: from sage.graphs.schnyder import minimal_schnyder_wood\n        sage: g = Graph([(0,-1),(0,-2),(0,-3),(-1,-2),(-2,-3),\n        ....:  (-3,-1)], format='list_of_edges')\n        sage: g.set_embedding({-1:[-2,0,-3],-2:[-3,0,-1],\n        ....:  -3:[-1,0,-2],0:[-1,-2,-3]})\n        sage: newg = minimal_schnyder_wood(g)\n        sage: newg.edges()\n        [(0, -3, 'red'), (0, -2, 'blue'), (0, -1, 'green')]\n        sage: newg.plot(color_by_label={'red':'red','blue':'blue',\n        ....:  'green':'green',None:'black'})\n        Graphics object consisting of 8 graphics primitives\n\n    A larger example::\n\n        sage: g = Graph([(0,-1),(0,2),(0,1),(0,-3),(-1,-3),(-1,2),\n        ....: (-1,-2),(1,2),(1,-3),(2,-2),(1,-2),(-2,-3)], format='list_of_edges')\n        sage: g.set_embedding({-1:[-2,2,0,-3],-2:[-3,1,2,-1],\n        ....: -3:[-1,0,1,-2],0:[-1,2,1,-3],1:[-2,-3,0,2],2:[-1,-2,1,0]})\n        sage: newg = minimal_schnyder_wood(g)\n        sage: sorted(newg.edges(), key=lambda e:(str(e[0]),str(e[1])))\n        [(0, -1, 'green'),\n         (0, -3, 'red'),\n         (0, 2, 'blue'),\n         (1, -2, 'blue'),\n         (1, -3, 'red'),\n         (1, 0, 'green'),\n         (2, -1, 'green'),\n         (2, -2, 'blue'),\n         (2, 1, 'red')]\n        sage: newg2 = minimal_schnyder_wood(g, minimal=False)\n        sage: sorted(newg2.edges(), key=lambda e:(str(e[0]),str(e[1])))\n        [(0, -1, 'green'),\n         (0, -3, 'red'),\n         (0, 1, 'blue'),\n         (1, -2, 'blue'),\n         (1, -3, 'red'),\n         (1, 2, 'green'),\n         (2, -1, 'green'),\n         (2, -2, 'blue'),\n         (2, 0, 'red')]\n\n    TESTS::\n\n        sage: minimal_schnyder_wood(graphs.RandomTriangulation(5))\n        Digraph on 5 vertices\n        sage: minimal_schnyder_wood(graphs.CompleteGraph(5))\n        Traceback (most recent call last):\n        ...\n        ValueError: not a planar graph\n        sage: minimal_schnyder_wood(graphs.WheelGraph(5))\n        Traceback (most recent call last):\n        ...\n        ValueError: not a triangulation\n        sage: minimal_schnyder_wood(graphs.OctahedralGraph(),root_edge=(0,5))\n        Traceback (most recent call last):\n        ...\n        ValueError: not a valid root edge\n    \"\"\"\n    if root_edge is None:\n        a = -1\n        b = -2\n    else:\n        a, b = root_edge\n\n    if check:\n        if not graph.is_planar():\n            raise ValueError('not a planar graph')\n        if not all(len(u) == 3 for u in graph.faces()):\n            raise ValueError('not a triangulation')\n        if not(a in graph.neighbors(b)):\n            raise ValueError('not a valid root edge')\n\n    new_g = DiGraph()\n    emb = graph.get_embedding()\n\n    # finding the third outer vertex c\n    emb_b = emb[b]\n    idx_a = emb_b.index(a)\n    c = emb_b[(idx_a + 1) % len(emb_b)]\n\n    # initialisation\n    for i in emb[c]:\n        if i != a and i != b:\n            new_g.add_edge((i, -3, 'red'))\n\n    path = list(emb[c])\n    idxa = path.index(a)\n    path = path[idxa:] + path[:idxa]\n    neighbors_in_path = {i: len([u for u in graph.neighbors(i) if u in path])\n                         for i in graph}\n    removable_nodes = [u for u in path if neighbors_in_path[u] == 2 and\n                       u != a and u != b]\n\n    # iterated path shortening\n    while len(path) > 2:\n        if minimal:\n            v = removable_nodes[-1]   # node to be removed from path\n        else:\n            v = removable_nodes[0]   # node to be removed from path\n        idx_v = path.index(v)\n        left = path[idx_v - 1]\n        new_g.add_edge((v, left, 'green'))\n        right = path[idx_v + 1]\n        new_g.add_edge((v, right, 'blue'))\n        neighbors_v = emb[v]\n        idx_left = neighbors_v.index(left)\n        neighbors_v = neighbors_v[idx_left:] + neighbors_v[:idx_left]\n        idx_right = neighbors_v.index(right)\n        inside = neighbors_v[1:idx_right]\n        new_g.add_edges([(w, v, 'red') for w in inside])\n        path = path[:idx_v] + inside + path[idx_v + 1:]\n        # updating the table of neighbors_in_path\n        for w in inside:\n            for x in graph.neighbors(w):\n                neighbors_in_path[x] += 1\n        for x in graph.neighbors(v):\n            neighbors_in_path[x] -= 1\n        # updating removable nodes\n        removable_nodes = [u for u in path if neighbors_in_path[u] == 2 and\n                           u != a and u != b]\n\n    def relabel(w):\n        return -3 if w == c else w\n\n    emb = {relabel(v): [relabel(u) for u in emb[v]] for v in graph}\n    for u, v, w in (a, b, -3), (b, -3, a), (-3, a, b):\n        idx = emb[u].index(v)\n        if idx == 0:\n            emb[u] = emb[u][1:-1]\n        else:\n            emb[u] = emb[u][idx+1:] + emb[u][:idx-1]\n\n    new_g.set_embedding(emb)\n    return new_g\n", "meta": {"hexsha": "dc11b61e4d471c8d56aee0941032ba7b3ea4f506", "size": 29983, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/graphs/schnyder.py", "max_stars_repo_name": "Ivo-Maffei/DistanceRegular", "max_stars_repo_head_hexsha": "d4dedd5c3e7da73111168fcce60d1f180fe24019", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-19T22:34:03.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-19T22:34:03.000Z", "max_issues_repo_path": "src/sage/graphs/schnyder.py", "max_issues_repo_name": "Ivo-Maffei/DistanceRegular", "max_issues_repo_head_hexsha": "d4dedd5c3e7da73111168fcce60d1f180fe24019", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/graphs/schnyder.py", "max_forks_repo_name": "Ivo-Maffei/DistanceRegular", "max_forks_repo_head_hexsha": "d4dedd5c3e7da73111168fcce60d1f180fe24019", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-03-29T17:13:36.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-03T18:11:28.000Z", "avg_line_length": 35.0268691589, "max_line_length": 144, "alphanum_fraction": 0.5508454791, "include": true, "reason": "from sage", "num_tokens": 7962, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.480478678047907, "lm_q2_score": 0.12421300511003351, "lm_q1q2_score": 0.05968170049162682}}
{"text": "import logging\nimport traceback\nimport os\nfrom typing import Dict\nfrom math import ceil\nfrom itertools import repeat, takewhile\n\nimport multiprocessing\nimport numpy as np\n\nfrom playground.main import get_args\nfrom playground import ColorizedLogger, Configuration, timeit\n\n# Create loggers with different colors to use in each problem\nmain_logger = ColorizedLogger('Main', 'yellow')\np1_logger = ColorizedLogger('Problem1', 'blue')\np2_logger = ColorizedLogger('Problem2', 'green')\np3_logger = ColorizedLogger('Problem3', 'magenta')\nextra_ch_logger = ColorizedLogger('ExtraMain', 'yellow')\nextra_sub_ch_logger = ColorizedLogger('ExtraSub', 'cyan')\n\n\n# Global Vars (For the Extra Challenges)\n# lock: multiprocessing.Lock\n# multi_list: List = []\n\n\ndef my_pid(x: int) -> None:\n    \"\"\" Problem 1 function to be called using pool.map\n\n    Parameters:\n        x: the id of the worker\n    \"\"\"\n\n    pid = os.getpid()\n    p1_logger.info(f\"Hi, I’m worker {x} (with {pid})\")\n\n\ndef problem1(conf: Dict) -> None:\n    \"\"\" Problem 1 solution\n\n    Parameters:\n         conf: The config loaded from the yml file\n            Example:\n                properties:\n                  pool_size: 4\n                  chunk_size: 1\n                  x_min: 0\n                  x_max: 9\n                conf_type: required\n    \"\"\"\n\n    p1_logger.info(\"Starting Problem 1..\")\n    conf_props = conf['properties']\n    # Generate iterable from `x_min` to `x_max`\n    xs = range(conf_props[\"x_min\"], conf_props[\"x_max\"] + 1)\n    p1_logger.info(f\"Pool Size: {conf_props['pool_size']}: Will call `my_pid` for x in {tuple(xs)}\")\n    # Call my_pid() using pool.map()\n    with multiprocessing.Pool(processes=conf_props['pool_size']) as pool:\n        # https://docs.python.org/3/library/multiprocessing.html#multiprocessing.pool.Pool.map\n        pool.map(func=my_pid,\n                 iterable=xs,\n                 chunksize=conf_props['chunk_size'])\n\n\n# Call the timeit wrapper from main.py and pass it a custom string to print\n# It already supports string formatting for func_name`, `args`, and `duration`\n# To reference the first positional argument of the function I wrap, I can use {0}\n@timeit(custom_print='N={0}: Calculation of pi took: {duration:2.5f} sec(s) total')\ndef py_pi(N: int, real_pi: float) -> None:\n    \"\"\" Problem 2 function to be called using pool.starmap\n\n    Parameters:\n        N: Number of terms to be used to calculate pi\n        real_pi: Correct value of pi\n    \"\"\"\n\n    # Construct the equation\n    first_term = (4 / N)\n    list_to_be_summed = [1 / (1 + ((i - 0.5) / N) ** 2) for i in range(1, N + 1)]\n    second_term = sum(list_to_be_summed)\n    calced_pi = first_term * second_term\n    # Calculate the absolute difference between the calculated pi and real value of pi\n    pi_diff = abs(real_pi - calced_pi)\n    p2_logger.info(f\"N={N}: Pi({N}) = {calced_pi} (Real is {real_pi}, difference is {pi_diff})\")\n\n\ndef problem2(conf: Dict) -> None:\n    \"\"\" Problem 2 solution\n\n    Parameters:\n         conf: The config loaded from the yml file\n            Example:\n                properties:\n                  pool_size: 4\n                  chunk_size: 1\n                  num_terms_min: 10\n                  num_terms_step: 5\n                  num_terms_max: 3906250\n                conf_type: required\n\n    \"\"\"\n\n    p2_logger.info(\"Starting Problem 2..\")\n    real_pi = np.pi\n    conf_props = conf['properties']\n    # Generate iterable with number of terms to be used\n    # Lambda function that multiplies each element by 5 in the power of the element's index\n    # e.g. [(10, 0), (10, 1), (10, 2)] -> [10*5^0, 10*5^1, 10*5^2]\n    # the first ind_and_num would be (10, 0)\n    multiplied_series = lambda ind_and_num: (ind_and_num[1] *\n                                             (conf_props[\"num_terms_step\"] ** (ind_and_num[0])))\n    # Map an infinite enumerated iterable of (index, 10) to the lambda function\n    # Stop when the series exceeds 3906250\n    num_terms_range = takewhile(lambda series_el: series_el <= conf_props[\"num_terms_max\"],\n                                map(multiplied_series, enumerate(repeat(conf_props[\"num_terms_min\"]))))\n    num_terms_range = tuple(num_terms_range)  # I only do this because I want to print them\n    # Create the iterable of arguments to be passed to py_pi using pool.starmap()\n    # repeat() propagates the same `real_pi` value as many times as necessary\n    # to zip it with num_terms_range\n    args = zip(num_terms_range, repeat(real_pi))\n    p2_logger.info(f\"Will call `py_pi` for N in {tuple(num_terms_range)}\")\n    # Call py_pi() using pool.starmap() (starmap accepts iterable with multiple arguments)\n    with multiprocessing.Pool(processes=conf_props['pool_size']) as pool:\n        # https://docs.python.org/3/library/multiprocessing.html#multiprocessing.pool.Pool.map\n        pool.starmap(func=py_pi,\n                     iterable=args,\n                     chunksize=conf_props['chunk_size'])\n\n\ndef py_pi_better(N: int, i_start: int, i_stop: int) -> float:\n    \"\"\" Problem 3 function to be called using pool.starmap\n\n    Parameters:\n        N: Number of terms to be used to calculate pi\n        i_start: The starting index of the sum used in pi's approximation\n        i_stop: The ending index of the sum used in pi's approximation\n    Returns:\n        partial_calced_pi: The part of pi's approximation calculated\n    \"\"\"\n\n    # Construct the equation\n    first_term = (4 / N)\n    list_to_be_summed = [1 / (1 + ((i - 0.5) / N) ** 2) for i in range(i_start, i_stop + 1)]\n    second_term = sum(list_to_be_summed)\n    cacled_pi = first_term * second_term\n    return cacled_pi\n\n\ndef problem3(conf: Dict) -> None:\n    \"\"\" Problem 3 solution\n\n    Parameters:\n         conf: The config loaded from the yml file\n            Example:\n                properties:\n                  pool_size: 4\n                  chunk_size: 1\n                  num_terms:\n                    - 100\n                    - 500\n                    - 1000\n                    - 2000\n                    - 10000\n                    - 50000\n                conf_type: required\n    \"\"\"\n\n    p3_logger.info(\"Starting Problem 3..\")\n    conf_props = conf['properties']\n    p3_logger.info(f\"Will call `py_pi_better` for N in {tuple(conf_props['num_terms'])}\")\n    # Run the pi calculation once for each number of terms requested in the yml\n    for num_term in conf_props[\"num_terms\"]:\n        # Split the work of `num_terms` into `pool_size` number of parts\n        step = ceil(num_term / conf_props[\"pool_size\"])\n        i_start = range(1, num_term, step)\n        i_stop = map(lambda el: el + step - 1 if el + step - 1 <= num_term else num_term, i_start)\n        # Zip N with the i_start and i_stop iterables. Propagate the same N value using repeat\n        args = zip(repeat(num_term), i_start, i_stop)\n        # Call py_pi_better() using pool.starmap() (starmap accepts iterable with multiple arguments)\n        with multiprocessing.Pool(processes=conf_props['pool_size']) as pool:\n            # timeit can be used as a context manager too. Pass it a custom string and count the\n            # total time to calculate pi\n            custom_string = f'N={num_term}: Parallel calculation of pi took: ' + \\\n                            '{duration:2.5f} sec(s) total'\n            with timeit(custom_print=custom_string):\n                # https://docs.python.org/3/library/multiprocessing.html#multiprocessing.pool.Pool.map\n                pi_chunks = pool.starmap(func=py_pi_better,\n                                         iterable=args,\n                                         chunksize=conf_props['chunk_size'])\n                calced_pi = sum(pi_chunks)\n        real_pi = np.pi\n        pi_diff = abs(real_pi - calced_pi)\n        p3_logger.info(f\"N={num_term}: Pi({num_term}) = {calced_pi} (Real is {real_pi}, \"\n                       f\"difference is {pi_diff})\")\n\n\ndef extra_1(conf_props: Dict):\n    \"\"\" Extra Challenge 1 solution\n\n    Parameters:\n         conf_props: The config loaded from the yml file\n            Example:\n                pool_sizes:\n                  - 2\n                  - 4\n                  - 8\n                  - 16\n                  - 32\n                chunk_size: 1\n                num_term: 8000000\n    \"\"\"\n\n    num_term = int(conf_props[\"num_term\"])\n    extra_ch_logger.info(\"Will call `py_pi_better` for pool_size in \"\n                         f\"{tuple(conf_props['pool_sizes'])}\")\n    for pool_size in conf_props[\"pool_sizes\"]:\n        pool_size = int(pool_size)\n        # Slightly modified code from problem 3\n        extra_sub_ch_logger.info(f\"Pool Size={pool_size}: Calling workers for N={num_term}\")\n        step = ceil(num_term / pool_size)\n        i_start = range(1, num_term, step)\n        i_stop = map(lambda el: el + step - 1 if el + step - 1 <= num_term else num_term, i_start)\n        args = zip(repeat(num_term), i_start, i_stop)\n        with multiprocessing.Pool(processes=pool_size) as pool:\n            custom_string = f'Pool Size={pool_size}: Calculation of pi for N={num_term} took: ' + \\\n                            '{duration:2.5f} sec(s) total'\n            with timeit(custom_print=custom_string):\n                pi_chunks = pool.starmap(func=py_pi_better,\n                                         iterable=args,\n                                         chunksize=conf_props['chunk_size'])\n                calced_pi = sum(pi_chunks)\n        real_pi = np.pi\n        pi_diff = abs(real_pi - calced_pi)\n        extra_sub_ch_logger.info(f\"Pool Size={pool_size}: Pi({num_term}) = {calced_pi} \"\n                                 f\"(Real is {real_pi}, difference is {pi_diff})\")\n\n\ndef py_pi_better_with_queue(N: int, i_start: int, i_stop: int,\n                            m_queue: multiprocessing.Queue) -> None:\n    \"\"\" Extra Challenge 2 function to be called using pool.call_async\n\n    Parameters:\n        N: Number of terms to be used to calculate pi\n        i_start: The starting index of the sum used in pi's approximation\n        i_stop: The ending index of the sum used in pi's approximation\n        m_queue: A queue in which to append the results\n    \"\"\"\n\n    # Construct the equation\n    first_term = (4 / N)\n    list_to_be_summed = [1 / (1 + ((i - 0.5) / N) ** 2) for i in range(i_start, i_stop + 1)]\n    second_term = sum(list_to_be_summed)\n    cacled_pi = first_term * second_term\n    m_queue.put(cacled_pi)\n\n\ndef extra_2(conf_props: Dict):\n    \"\"\" Extra Challenge 2 solution\n\n    Parameters:\n         conf_props: The config loaded from the yml file\n            Example:\n                pool_sizes:\n                  - 2\n                  - 4\n                  - 8\n                  - 16\n                  - 32\n                num_term: 8000000\n    \"\"\"\n\n    num_term = int(conf_props[\"num_term\"])\n\n    extra_ch_logger.info(\"Will call `py_pi_better_with_queue` for pool_size in \"\n                         f\"{tuple(conf_props['pool_sizes'])}\")\n    for pool_size in conf_props[\"pool_sizes\"]:\n        pool_size = int(pool_size)\n        # Create a multiprocessing manager and a Queue\n        multi_manager = multiprocessing.Manager()\n        multi_queue = multi_manager.Queue()\n        # Slightly modified code from problem 3\n        extra_sub_ch_logger.info(f\"Pool Size={pool_size}: Calling Async workers for N={num_term}\")\n        step = ceil(num_term / pool_size)\n        i_start = range(1, num_term, step)\n        i_stop = map(lambda el: el + step - 1 if el + step - 1 <= num_term else num_term, i_start)\n        args = zip(repeat(num_term), i_start, i_stop, repeat(multi_queue))\n        # Setup manually a Pool\n        custom_string = f'Pool Size={pool_size}: Calculation of pi for N={num_term} and  ' + \\\n                        'took: {duration:2.5f} sec(s) total'\n        with timeit(custom_print=custom_string):\n            pool = multiprocessing.Pool(processes=pool_size)\n            pool.starmap_async(func=py_pi_better_with_queue, iterable=args)\n            pi_chunks = []\n            while len(pi_chunks) < pool_size:\n                pi_chunks.append(multi_queue.get())\n            calced_pi = sum(pi_chunks)\n        real_pi = np.pi\n        pi_diff = abs(real_pi - calced_pi)\n        extra_sub_ch_logger.info(f\"Pool Size={pool_size}: Pi({num_term}) = {calced_pi}\"\n                                 f\"(Real is {real_pi}, difference is {pi_diff})\")\n        pool.close()\n        pool.join()\n\n\ndef init(_lock, _multi_list):\n    global lock\n    global multi_list\n    lock = _lock\n    multi_list = _multi_list\n\n\ndef py_pi_better_with_list(N: int, i_start: int, i_stop: int) -> None:\n    \"\"\" Extra Challenge 2 function to be called using pool.call_async\n\n    Parameters:\n        N: Number of terms to be used to calculate pi\n        i_start: The starting index of the sum used in pi's approximation\n        i_stop: The ending index of the sum used in pi's approximation\n    \"\"\"\n\n    # Construct the equation\n    first_term = (4 / N)\n    list_to_be_summed = [1 / (1 + ((i - 0.5) / N) ** 2) for i in range(i_start, i_stop + 1)]\n    second_term = sum(list_to_be_summed)\n    cacled_pi = first_term * second_term\n    lock.acquire()\n    multi_list.append(cacled_pi)\n    lock.release()\n\n\ndef extra_3(conf_props: Dict):\n    \"\"\" Extra Challenge 3 solution\n\n    Parameters:\n         conf_props: The config loaded from the yml file\n    \"\"\"\n\n    num_term = int(conf_props[\"num_term\"])\n\n    extra_ch_logger.info(\"Will call `py_pi_better_with_list` for pool_size in \"\n                         f\"{tuple(conf_props['pool_sizes'])}\")\n    for pool_size in conf_props[\"pool_sizes\"]:\n        pool_size = int(pool_size)\n        # Create a multiprocessing manager and a Queue\n        manager = multiprocessing.Manager()\n        multi_list = manager.list()\n        _lock = multiprocessing.Lock()\n        # Slightly modified code from problem 3\n        extra_sub_ch_logger.info(f\"Pool Size={pool_size}: Calling Async workers for N={num_term}\")\n        step = ceil(num_term / pool_size)\n        i_start = range(1, num_term, step)\n        i_stop = map(lambda el: el + step - 1 if el + step - 1 <= num_term else num_term, i_start)\n        args = zip(repeat(num_term), i_start, i_stop)\n        # Setup manually a Pool\n        custom_string = f'Pool Size={pool_size}: Calculation of pi for N={num_term} and  ' + \\\n                        'took: {duration:2.5f} sec(s) total'\n        with timeit(custom_print=custom_string):\n            pool = multiprocessing.Pool(initializer=init, initargs=(_lock, multi_list),\n                                        processes=pool_size)\n            pool.starmap_async(func=py_pi_better_with_queue, iterable=args)\n            pi_chunks = []\n            while len(multi_list) < pool_size:\n                pi_chunks = multi_list\n            calced_pi = sum(pi_chunks)\n        real_pi = np.pi\n        pi_diff = abs(real_pi - calced_pi)\n        extra_sub_ch_logger.info(f\"Pool Size={pool_size}: Pi({num_term}) = {calced_pi}\"\n                                 f\"(Real is {real_pi}, difference is {pi_diff})\")\n        pool.close()\n        pool.join()\n\n\ndef extra_challenges(conf: Dict) -> None:\n    \"\"\" Extra Challenges solution\n\n    Parameters:\n         conf: The config loaded from the yml file\n            Example: Examples of each sub-config in each problem's function\n    \"\"\"\n\n    extra_ch_logger.info(\"Starting the Extra Challenges..\")\n    # Run all the extra challenge that have the property enabled: True\n    if conf['properties'][\"ch1\"][\"enabled\"]:\n        extra_ch_logger.info(\"1: Test performance for different pool sizes.\")\n        extra_1(conf['properties'][\"ch1\"])\n    if conf['properties'][\"ch2\"][\"enabled\"]:\n        extra_ch_logger.info(\"2: Collect results from workers using multiprocessing list \"\n                             \"(using starmap_async).\")\n        extra_2(conf['properties'][\"ch2\"])\n    if conf['properties'][\"ch3\"][\"enabled\"]:\n        extra_ch_logger.info(\"3: Collect results from workers using a pythonic list \"\n                             \"(using starmap_async and Lock()).\")\n        extra_3(conf['properties'][\"ch3\"])\n    else:\n        extra_ch_logger.info(\"3: Collect results from workers using a pythonic list \"\n                             \"(using starmap_async and Lock()).\")\n        extra_ch_logger.info(\"Last progress report:\")\n        extra_ch_logger.info(\"For this and the 4th problem, I managed to create a Lock() and share it\")\n        extra_ch_logger.info(\"with the workers by creating an initializer function for the Pool().\")\n        extra_ch_logger.info(\"The problem was that when I did the same with the multiprocessing \"\n                             \"List() or Array(), \")\n        extra_ch_logger.info(\"I wasn't able to access them from the function that spawned them.\")\n\n\n@timeit()\ndef main():\n    \"\"\" This is the main function of assignment.py\n\n    Example:\n        python assignment1/assignment.py \\\n            -c ../confs/assignment1.yml \\\n            -l ../logs/assignment.log\n    \"\"\"\n\n    # Initialize\n    args = get_args()\n    ColorizedLogger.setup_logger(args.log, args.debug)\n    main_logger.info(\"Starting Assignment 1\")\n    # Load the configuration\n    conf = Configuration(config_src=args.config_file)\n    # Start the problems defined in the configuration\n    main_logger.info(f\"{' Required Problems ':-^{100}}\")\n    check_required = lambda conf_type, tag: ((conf_type == 'required' or tag != 'required_only')\n                                             and conf_type != 'disabled')\n    # For each problem present in the config file, call the appropriate function\n    if 'problem1' in conf.config_keys:\n        for bench_conf in conf.get_config(config_name='problem1'):\n            if check_required(bench_conf['type'], conf.tag):\n                problem1(bench_conf)\n    if 'problem2' in conf.config_keys:\n        for bench_conf in conf.get_config(config_name='problem2'):\n            if check_required(bench_conf['type'], conf.tag):\n                problem2(bench_conf)\n    if 'problem3' in conf.config_keys:\n        for bench_conf in conf.get_config(config_name='problem3'):\n            if check_required(bench_conf['type'], conf.tag):\n                problem3(bench_conf)\n    # Run the extra challenges if the tag of the conf is not set as \"required_only\"\n    main_logger.info(f\"{' Optional Problems ':-^{100}}\")\n    if 'extra_challenges' in conf.config_keys:\n        for bench_conf in conf.get_config(config_name='extra_challenges'):\n            if check_required(bench_conf['type'], conf.tag):\n                extra_challenges(bench_conf)\n    main_logger.info(\"Assignment 1 Finished\")\n\n\nif __name__ == '__main__':\n    try:\n        main()\n    except Exception as e:\n        logging.error(str(e) + '\\n' + str(traceback.format_exc()))\n        raise e\n", "meta": {"hexsha": "5651f01a033d1cd5ff222b646e2350f4e3f392d0", "size": 18681, "ext": "py", "lang": "Python", "max_stars_repo_path": "assignment1/assignment1.py", "max_stars_repo_name": "drkostas/DSE512-playground", "max_stars_repo_head_hexsha": "1e47ae2878cc9f3f00fdbd81626189657d642061", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "assignment1/assignment1.py", "max_issues_repo_name": "drkostas/DSE512-playground", "max_issues_repo_head_hexsha": "1e47ae2878cc9f3f00fdbd81626189657d642061", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 17, "max_issues_repo_issues_event_min_datetime": "2021-02-15T01:43:46.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-04T02:32:32.000Z", "max_forks_repo_path": "assignment1/assignment1.py", "max_forks_repo_name": "drkostas/DSE512-playground", "max_forks_repo_head_hexsha": "1e47ae2878cc9f3f00fdbd81626189657d642061", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.1475770925, "max_line_length": 103, "alphanum_fraction": 0.6123869172, "include": true, "reason": "import numpy", "num_tokens": 4462, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4726834766204328, "lm_q2_score": 0.12592276811536138, "lm_q1q2_score": 0.059521611818437604}}
{"text": "\"\"\"\n\nReads a file containing columns of data and creates a dictionary according to header information\nusing the following format:\n\n1. comments start with ``#`` in the **first column** : ``# My Comment``\n\n2. header information starts with ``#!``, where ``#`` is also in the **first column**. It must precede the data.\n\n3. each columns is represented by ``name[dtype, col.nr.]/``,  *dtype* (optional) is the data type and *col.nr*\n   (starting at 0) is the column number\n\n4. data are separated by white space **NOT commas!**\n\n5. data types:\n\n      - s : string\n      - f : float\n      - i : integer\n\n6. blank lines are ignored\n\n **NOTE**: if data formats are entered they should be specified for all columns\n\nExample data::\n\n   #! p_miss[0]/ siglt[2]/ s01[3]/ alt[4]/\n   200. 1.35e-4 -1.e-3    0.1\n   220. 2.56e-4 -2.e-4    -0.1\n   230. 3.47e-6 -3.e-5    1.1\n\nThe header can also contain data type information::\n\n   #! p_miss[f,0]/ siglt[f,2]/ s01[f,3]/ alt[f,4]/\n\n   200. 1.35e-4 -1.e-3    0.1\n   220. 2.56e-4 -2.e-4    -0.1\n   230. 3.47e-6 -3.e-5    1.1\n\n\nExample that opens a file and create a dfile object::\n\n   >>> f0 = dfile('sig_LT.dat')\n\nLoop over content::\n\n   >>> for l in f0:\n   >>> ...pm = l['p_miss']\n   >>> ...sig_lt = l['siglt']*10000.\n   >>> ...print pm, sig_lt, l['alt']\n   >>> # end for l\n\n\nVariables can also be accessed directly as numpy arrays (if installed):\n\n   >>> pm = f0['p_miss']\n   >>> sig_lt = f0['siglt']*10000.\n\nThey can also be converted to attributes:\n\n   >>> f0.make_attr()\n   >>> print f0.p_miss\n   >>> print f0.sig_lt\n\nVariable names are also called keys.\n\nSave the data file as a csv file, this is useful for exporting and formatting for \ndocuments (other than latex)\n\n   >>> f0.write_csv(filename)\n\n\n---------------------------------------------------------\n\n\"\"\"\n\nimport sys\nimport os\nimport string\nimport math\nimport re\nimport pdb\n\nnumpy_ok = True\ntry:\n    import numpy as np\nexcept:\n    numpy_ok = False\n\n# function to create a dictionary from 2 lists: key, values\nformat_dict = {'i':'{:d}', 'f':'{:f}', 's':'{:s}'}\n# create a dictionary from  an array of keys and values\n#----------------------------------------------------------------------\ndef find_duplicates(array):\n    # array with no duplicates\n    na = []\n    # counter array\n    count = []\n    # arrays with duplucates\n    da = []\n    for a in array:\n        try:\n            na.index(a)\n        except:\n            na.append(a)\n            count.append(0.)\n    # na has no duplicates\n    for i,a in enumerate(na):\n        for aa in array:\n            if aa == a:\n                count[i]+= 1\n    for i,c in enumerate(count):\n        if c>1:\n            da.append(na[i])\n    return da\n#----------------------------------------------------------------------\n\n\nclass dfile:\n    \"\"\"\n    Open a file, read and interpret the contents and return a dfile object:\n\n    >>> df = dfile('my_datafile')\n\n    keywords:\n        \n        debug = False (default) : print additional iformation\n        \n        fast = False (default) : load data in a fast way (using np.loadtxt) this has\n                                 some limits for string entries. Best used for large purely\n                                 numerical data.\n                                 \n        use_numpy = True (if numpy is installed) : set automatically but can be overridden\n                                                   some attributes of datafile are not availables when\n                                                   numpy is not present\n        \n    \"\"\"\n    def __init__(self, filename, debug = False, new=False, skip = True, use_numpy = numpy_ok, fast = False):\n        self.H=re.compile(\"^#\\!\") # pattern for header\n        self.C=re.compile(\"^#\")   # pattern for comment\n        # pattern for splitting header\n        # currently:\n        # ^#\\! : matches line beginning with #!\n        # \\[[0-9]+\\]\\/: matches [0]/ ... [8796]/\n        # \\[ *\\w+ *, *\\w *\\]\\/ : matches [   f  , blabla   ]/\n        #\n        self.S=re.compile(\"^#\\!|\\[[0-9]+\\]\\/|\\[ *\\w *, *\\w+ *\\]\\/\")\n        # pattern to find format information in the header\n        self.F=re.compile(\"\\w+ *, *\\w+\")\n        # pattern to find a character\n        self.Fc=re.compile(\"[a-zA-Z]\")\n        # pattern to find a number\n        self.Fn=re.compile(\"[0-9]+ *\\]\")\n        # supported formats: the output format dictionary key must match the supported formats\n        self.fmt_characters = ['f','i','s']\n        self.dt_formats = {'f':'f8', 'i':'i4','s':'S32'}\n        self.output_format= {'f':'%r ','i':'%d ','s':'%s '}\n        # empty dictionary for the formats\n        self.formats = {}\n        self.formats_dt = {}\n        self.cols = {}\n        # flag for printing debugging information\n        self.debug = debug\n        # flat to ignore bad line in input\n        self.skip = skip\n        self.use_numpy = use_numpy\n        if not self.use_numpy:\n            print('numpy will not be used !')\n        if fast and (not use_numpy):\n            print ('fast mode not possible as numpy cannot be used!')\n            fast = False\n        self.fast = fast\n        #\n        self.header = None\n        self.data = []\n        self.adata = []\n        self.fdata=[]\n        self.keys=[]\n        self.new = False\n        if new:\n            new=True\n            self.filename = filename\n            self.keys.append('indx')\n            self.headindex=0\n            self.headerline = ('#! ')\n            self.adata.append('#! ')\n            return\n        # pdb.set_trace()\n        # open file\n        self.filename = filename\n        i=open(filename,\"r\")      # open file\n        # remove leading and trailing spaces\n        self.adata=[ x.strip() for x in i.readlines()]   # read all data        \n        if self.debug :\n            print(\"datafile --> data read !\")\n        if self.debug :\n            print(\"datafile --> spaces removed read !\")\n        self.remove_blanks()\n        if self.debug :\n            print(\"datafile --> blank lines removed read !\")\n        i.close()\n        if (self.find_header() != 0): # find the header\n            print(\"cannot interpret data, header probably missing or wrong\")\n            return\n        if self.debug :\n            print(\"datafile --> create arrays !\")\n        self.make_array()  # read data\n        if self.debug :\n            print(\"datafile --> arrays created !\")\n    def __getitem__(self,i):\n        # allows 'direct' access to the data\n        if type(i) is int:\n            # it'sm index\n            return self.data[i]\n        elif type(i) is str:\n            # its a lkey return the list of data\n            return self.get_data(i)\n    def __len__(self):\n        return len(self.data)\n    def remove_blanks(self):\n        # work through the list in reverse order\n        indices = list(range( len( self.adata ))) # list of indices\n        indices.reverse() # reverse order\n        for i in indices: # loop through from the top\n            if len(self.adata[i].strip()) == 0:\n                del self.adata[i]\n    def find_header(self):\n        # find header information : look for a line starting with #!\n        for l in self.adata:\n            if (self.H.match(l) != None):\n                self.headindex=self.adata.index(l)\n                self.headerline=l\n                self.header=re.split(self.S,l)[1:-1] # remove first and last element\n                self.keys=[ x.strip() for x in self.header]\n                self.keys.append('indx') # store the index into the original\n                # handle data format\n                # check for duplicate keys\n                duplicate_keys = find_duplicates(self.keys)\n                if duplicate_keys != []:\n                    print(\"duplicate keys found : \", duplicate_keys)\n                    return -1\n                # pdb.set_trace()\n                fmt = re.findall(self.F,l)\n                col_t = re.findall(self.Fn,l)\n                col = [cc.replace(']','') for cc in col_t]\n                # no format specification, set default format\n                if fmt == []:\n                    for i,k in enumerate(self.keys[:-1]) : # skip index\n                        self.formats[k] = 'f'\n                        self.formats_dt[k] = self.dt_formats['f']\n                # use format specifications\n                else:\n                    for i,f in enumerate(fmt):\n                        fc = re.findall(self.Fc,f)[0] # use 1st char. for format\n                        self.formats[self.keys[i]] = fc\n                        self.formats_dt[self.keys[i]] = self.dt_formats[fc]\n                # addformat for the index\n                self.formats['indx'] ='i'\n                self.formats_dt['indx'] = self.dt_formats['i']\n                # use format specifications\n                for i,cc in enumerate(col):\n                    f = self.formats[self.keys[i]]\n                    if f == 's':\n                        self.cols[self.keys[i]] = ''\n                    else:\n                        self.cols[self.keys[i]] = col[i]\n                self.cols['indx'] ='-1'\n                # addformat for the index\n                # adata array\n                # do some checks\n                if (len(self.keys)  != len(self.formats)):\n                    print(self.filename,\": problem in data formats !\")\n                    print(self.adata)\n                    return -1\n                return 0\n            #\n        print(self.filename,\": no header information !\")\n        print('data dump : ')\n        print(self.adata)\n        return -1\n\n    def parse_line(self, l):\n        if (self.C.match(l) != None) : # not a comment\n            return None\n        ll=l.split()\n        # handle file format problems\n        if len(ll) > (len(self.keys)-1) :\n            n_data = (len(self.keys)-1)\n            print(self.filename, ' error: more data than variable names !')\n            print(' ---> check header : ', self.headerline)\n            print('current line : ', self.line_n+1, ' ', ll)\n            if self.skip:\n                print('skipping !')\n                return None\n            else:\n                sys.exit(-1)\n        if len(ll) < (len(self.keys)-1) :\n            print(self.filename, ' error: too few data values !')\n            print(' ---> check header : ', self.headerline)\n            print('current line : ', self.line_n+1, ' ', ll)\n            if self.skip:\n                print('skipping !')\n                return None\n            else:\n                sys.exit(-1)\n        f = []\n        # now convert to values\n        for i,k in enumerate(ll):\n            # check if there are format specifications\n            f_err = False\n            try:\n                fmt = self.formats[self.keys[i]]\n                fc = fmt\n                # check that the format is supported\n                fi = self.fmt_characters.index(fmt)\n            except:\n                f_err = True\n                print('unknown format : ', fc, ' set to f')\n                fc = 'f'\n                self.formats[self.keys[i]] = 'f'\n            # now try to convert according to the format\n            try:\n                if fc == 'f':\n                    f.append(float(k)) # create a float\n                if fc == 'i':\n                    f.append(int(k))   # create an integer\n                if fc == 's':\n                    f.append(k)        # leave as string\n            except:\n                f.append(k) # if not possible leave it,\n                # but make a comment\n                if len(self.formats) == 0 :\n                    print('cannot convert : ', k, ' to float, line : ', self.line_n +1)\n                else:\n                    if (f_err ):\n                        print('cannot convert : ', k, ' line : ', self.line_n+1,\\\n                            ', problem with unknown format : ', fmt)\n                    else:\n                        print('cannot convert : ', k, ' line : ', self.line_n+1,\\\n                            ', with format :', fmt)\n        f.append(self.adata.index(l))\n        # pdb.set_trace()\n        return f\n\n    def make_array(self):\n        if self.fast:\n            # use loadtxt to get the data\n            data_types = [self.formats_dt[k] for k in self.keys[:-1]]\n            self.data = np.loadtxt(self.filename, dtype = {'names':self.keys[:-1], 'formats':data_types})\n        else:   \n               # create an array of dictionaries\n            self.data = []\n            n_data = len(self.adata)\n            for self.line_n, l in enumerate(self.adata):\n                f = self.parse_line(l)\n                if f == None:\n                    continue\n                self.data.append(self.make_dict(self.keys,f) )\n                if self.debug:\n                    print(\"processed data : \", self.line_n, \" out of \", n_data)\n            \n    def make_dict(self,keys,values):\n        # create a dictionary from a list of keys and values\n        p = []\n        for j,key in enumerate(keys): # loop over keys\n            try:\n                p.append( (key.strip(),values[j]) ) # an array of tuples\n                d=dict(p) # create a dictionary\n            except:\n                print('problem in data : ', key, values, j)\n            #\n        return d\n\n    def make_attr(self):\n        # make attributes out of the keys\n        for k in self.keys:\n            ka = ''\n            try:\n                self.__dict__[k]\n                # attrtibute exists append _d\n                ka = k + '_d'\n                print((\"{:s} exists using : {:s}\".format(k, ka)))\n            except:\n                ka = k\n            # replace periods with underscores\n            if self.use_numpy:\n                setattr(self, ka.replace('.','_'), np.array(self[k]))\n            else:\n                setattr(self, ka.replace('.','_'), self[k])\n                    \n\n    def scale(self, key, factor):\n        \"\"\"\n        multiply all values of key with a factor\n        \"\"\"\n        for i, d in enumerate(self.data):\n            self.data[i][key] = factor*d[key]\n        #\n\n    def sort(self, key, **kwargs):\n        \"\"\"\n        sort the data according to the values in key\n        \"\"\"\n        index_array = []\n        for d in self.data:\n            index_array.append((d[key], self.data.index(d))) # store index and values pair\n        sorted_array = sorted(index_array,**kwargs) # create a sorted array\n        temp = []\n        for ip in sorted_array:\n            temp.append(self.data[ip[1]])\n        self.data = temp\n        temp=[]\n\n    def name(self):\n        \"\"\"\n        print the filename associate with this instance\n\n        \"\"\"\n        print(\"Input file name : \", self.filename)\n    def show_keys(self):\n        \"\"\"\n        print a list of variable names in the dictionary\n\n        \"\"\"\n        print(self.keys)\n    def get_keys(self):\n        \"\"\"\n\n        return a list of keys\n\n        \"\"\"\n        return self.keys\n    def get_header(self):\n        \"\"\"\n\n        return the header lines\n\n        \"\"\"\n        return self.adata[self.headindex]\n\n    def get_full_header(self):\n        \"\"\"\n\n        return all line up to the header line\n\n        \"\"\"\n        return self.adata[:self.headindex+1]\n\n    def show_data(self,keylist):\n        \"\"\"\n\n        print all the data corresponding to the key list::\n\n           >>> df.show_data('key1:key2:key3')\n\n        \"\"\"\n        akey=keylist.split(\":\")\n        for l in self.data:\n            ll=[]\n            for i in akey:\n                format = self.output_format[ self.formats[i] ]\n                ll.append( format%( l[i] ) )\n            print(ll)\n\n\n    def check_data(self, func, data, key, *args):\n        \"\"\"\n\n        function used to check if data fulfill a condition provided\n        by the user. The function is assumed to return True of False.\n\n        \"\"\"\n        return func( data, key, *args)\n\n    def select_data(self, sel_func = None, sel_args = None):\n        \"\"\"\n        returns an iterator for the data. As in get_data() a selector function and\n        its arguments can be supplied:\n\n        conditions can be applied:\n\n        1) sel_func: a user provided function returning True or False\n\n        2) sel_args: a list of arguments used in the sel_func function\n\n        The iterator returned can be used as follows:\n\n        >>> for d in df.select_data():\n        >>> ...print d\n\n        or the result can be converted to a list:\n\n        >>> list(df.select_data())\n\n        Using a selector function:\n\n        Example: assume the data contain a variable (key) called 'name'\n           you want to select only those data where name contains a certain substring 'sub'\n\n        Define this function:\n\n        >>> def myfind(data, key , what):\n        >>> ...where = data[key]\n        >>> ...return (str.find(where, what) >= 0)\n\n        now you can select the data using:\n\n        >>> list( df.select_data( myfind, 'name', 'sub') )\n\n        \"\"\"\n        if sel_func == None:\n            for i,data in enumerate(self.data):\n                yield data\n        else:\n            for i,data in enumerate(self.data):\n                if self.check_data(sel_func, data, *sel_args):\n                    yield data\n        # that's all\n\n    def select_data_eval(self, eval_str):\n        \"\"\"\n        returns an iterator for data selected with an *eval* expression\n        stored in the string `eval_str` each dataset item is accessed using the name data::\n\n        >>> df.select_data_eval(\"data['x'] >= 0.\")\n\n        returns only those data items where the value of the x-column in the file\n        is larger than or equal to 0.\n\n        \"\"\"\n        for i,data in enumerate(self.data):\n            if eval( eval_str):\n                yield data\n        # that's all\n\n    def eval_data(self, eval_str):\n        \"\"\"\n        iterator over all data evaluating an expression contained in eval_str\n        \"\"\"\n        for i,data in enumerate(self.data):\n            yield eval(eval_str)\n        # that's all\n\n    def get_data(self,key, sel_func = None, sel_args = None):\n        \"\"\"\n\n        return all data for `key` subject to the results of a selector function.\n\n        one can define a selector function (`sel_func`) using the arguments stored in `sel_args`.\n        This function is evaluated for each data record and only\n        those data are returned for which the condition is fulfilled.\n\n        1) sel_func: a user provided function returning True or False\n\n        2) sel_args: a list of arguments used in the sel_func function\n\n        Example::\n           assume the data contain a variable (key) called 'name'\n           you want to select only those data where name contains a certain substring 'Jo'\n\n        Define this function::\n\n        >>> def myfind(data, key , what):\n        >>> ...where = data[key]\n        >>> ...return (str.find(where, what) >= 0)\n\n        now you can select the data using::\n\n        >>> df.get_data('name',myfind, ['name','Jo'] )\n\n        This should return a list of names containing the substring 'Jo'\n\n        \"\"\"\n        array=[]\n        for l in self.data:\n            if sel_func == None:\n                array.append(l[key])\n            else :\n                if self.check_data( sel_func, l, *sel_args):\n                    array.append(l[key])\n        if self.use_numpy:\n            return np.array(array)\n        else:\n            return array\n\n    def get_data_eval(self,key,eval_str): # return data for a  key\n        \"\"\"\n\n        return all data for the `key` under the condition that the expression in `eval_str`\n        is True.\n\n        \"\"\"\n        array=[]\n        for l in self.select_data_eval(eval_str):\n            array.append(l[key])\n        if self.use_numpy:\n            return np.array(array)\n        else:\n            return array\n\n\n    def get_data_list(self,keylist, sel_func = None, sel_args = None):\n\n        \"\"\"\n\n        return all the data corresponding to the key list\n        as follows::\n\n           >>> a = df.get_data_list('key1:key2:key3')\n\n           >>> a = df.get_data_list('key1:key2:key3', myfind, ['name','J'])\n\n        return those data where the `name` values contain the character `J`\n\n        *a* contains the list of data\n\n        \"\"\"\n\n        akey=keylist.split(\":\")\n        dd = []\n        if sel_func == None:\n            for l in self.data:\n                ll=[]\n                for i in akey:\n                    ll.append( l[i] )\n                dd.append(ll)\n            if self.use_numpy:\n                return np.array(dd)\n            else:\n                return dd\n        else:\n            for l in self.data:\n                if self.check_data(sel_func, l, *sel_args):\n                    ll=[]\n                    for i in akey:\n                        ll.append( l[i] )\n                    dd.append(ll)\n            if self.use_numpy:\n                return np.array(dd)\n            else:\n                return dd\n\n    def get_data_list_eval(self,keylist, eval_str):\n        \"\"\"\n\n        similar function as select_data_eval but it only returns the\n        values for the keys defined in `keylist`.\n\n        \"\"\"\n        akey=keylist.split(\":\")\n        dd = []\n\n        for l in self.select_data_eval(eval_str):\n            ll=[]\n            for i in akey:\n                ll.append( l[i] )\n            dd.append(ll)\n        if self.use_numpy:\n            return np.array(dd)\n        else:\n            return dd\n\n    def show_all_data(self):\n        \"\"\"\n\n        print all data and keys stored\n\n        \"\"\"\n        for l in self.data:\n            print(l)\n    def get_all_data(self):\n        \"\"\"\n\n        return a list of all data stored\n\n        \"\"\"\n        return self.data\n    def write_complete_header(self,fp):\n        \"\"\"\n        write entire header including comments and internal parameters to file with\n        handle fp. Example:\n            \n        fp = open('mydile.data','w')\n        \n        datafile.write_comlete_header(fp)\n        \n        \"\"\"\n        for i,l in enumerate(self.adata[0:self.headindex]):\n            fp.write(l+'\\n')\n        # write header line\n        h = '#! '\n        n = 0\n        for k in self.keys[:-1]:\n            h = h + k+'['+'%s,%d'%(self.formats[k],n)+']/ '\n            n = n +1\n        fp.write(h+'\\n')\n    def update_header(self):\n        \"\"\"\n        update header line of this data file including format. This\n        makes sure that the header line is in sync with the dictionary keys\n        \"\"\"\n        # write header line\n        h = '#! '\n        n = 0\n        for k in self.keys[:-1]:\n            h = h + k+'['+'%s,%d'%(self.formats[k],n)+']/ '\n            n = n +1\n        # update data arrays\n        self.adata[self.headindex]=h\n        self.headerline = h\n    def write_header(self,fp):\n        \"\"\"\n        write only header line of this data file into file fp, including format\n        \"\"\"\n        # write header line\n        h = '#! '\n        n = 0\n        for k in self.keys[:-1]:\n            h = h + k+'['+'%s,%d'%(self.formats[k],n)+']/ '\n            n = n +1\n        fp.write(h+'\\n')\n    def write_line(self,fp, i):\n        \"\"\"\n        write data line i into file fp\n        \"\"\"\n        l = ''\n        # check array boundary\n        ndata = len(self.data)\n        if (i<0) :\n            print('index below lower bound, set to 0')\n            i = 0\n        if (i>=ndata):\n            print('index above upper bound, set to : ', ndata-1)\n        for k in self.keys[:-1]:\n            format = self.output_format[ self.formats[k] ]\n            l = l + format%(self.data[i][k])\n        fp.write(l+'\\n')\n    def write_all(self,fp, complete_header = False):\n        \"\"\"\n        write all data to a file associated to fp\n\n        if complete_header = True include the complete header including all comments\n        \"\"\"\n        if complete_header:\n            self.write_complete_header(fp)\n        else:\n            self.write_header(fp)\n        for i in range(len(self.data)):\n            self.write_line(fp, i)\n        fp.close()\n    #   new function to add a key\n    def write_selected(self,fp,index_list, complete_header = False):\n        \"\"\"\n        write a new datafile with an identical header but enter only\n        those data with an index given in index_list. If the index does not\n        exist print a message and skip it.\n\n        if complete_header = True include the complete header including all comments\n\n        \"\"\"\n        if complete_header:\n            self.write_complete_header(fp)\n        else:\n            self.write_header(fp)\n        for i in index_list:\n            try:\n                self.write_line(fp, i)\n            except:\n                print('cannot write index : ', i, ' does it exist ?')\n        fp.close()\n\n    def add_key(self,key,format='f'):\n        \"\"\"\n        add a new key, this is useful if you want to add new data\n        assign new values using a loop like::\n\n        >>> df.add_key('newkey',format='i')\n\n        The new data need to be stored as follows::\n\n        >>> for d in df.data:\n        >>>     d['newkey']= some_new_value\n\n        where df is the datafile and 'newkey' the new key. The new data set\n        can be saved using ``fp = open('new_file','w')`` and ``df.write_all(fp)``\n        \"\"\"\n        # check if key already exists\n        try:\n            self.keys.index(key)\n            print(key, \" exists already !\")\n            return\n        except:\n            for d in self.data:\n                # set initial value to none\n                d[key] = None\n        # add the new key at the end of the keys list but before indx\n        self.keys.insert(len(self.keys)-1,key)\n        # add the format information\n        try:\n            fi = self.fmt_characters.index(format)\n        except:\n            print('unknown format : ', format, ' use f instead')\n            format = 'f'\n        self.formats[key] =  format\n        self.update_header()\n    # end\n    def delete_key(self,key):\n        \"\"\"\n        remove a key and all values associated with it\n        \"\"\"\n        # remove the data for the key\n        for d in self.data:\n            del d[key]\n        # remove the format for this key\n        fmt = self.formats.pop(key)\n        # now remove the key from the key list\n        self.keys.remove(key)\n        print('key : ', key , ' and format : ', fmt, ' removed')\n        self.update_header()\n    # end\n\n    def add_data(self, keys,line):\n        \"\"\"\n        \n        add data to the data file\n        \n        d.add_data('x:y:z','xval yval zval')\n        \n\n        xval, yval, zval are the values as they would be netered in a data file line\n        \n        both arguments are strings !\n        \n        \n        IMPORTANT: add the values to all current lines of the data file !\n        \n        \"\"\"\n        \n        key_l = keys.split(':')\n        # check the key list\n        key_index=[]\n        for k in self.keys[:-1]:  # skip the indx\n            try:\n                ki = key_l.index(k)\n                key_index.append(ki)\n            except:\n                print(k, ' does not exist !, nothing added')\n                return\n        # sort the argumens according to the sequence of the keys\n        lsp = line.split()\n        fline = [lsp[i] for i in key_index]\n        line = ''\n        for fl in fline: line += fl+' '\n        self.adata.append(line.strip())\n        print(line)\n        \"\"\"\n        f = self.parse_line(line.strip())\n        self.data.append(self.make_dict(self.keys,f) )\n        \"\"\"\n        self.make_array()\n\n    def add_header_comment(self, text):\n        \"\"\"\n        add a comment line to the header. The # at the beginning is automatically added !\n\n        * for a normal comment start with a space\n        * to add a parameter start the comment with a \\\n        \"\"\"\n        self.adata.insert(self.headindex, '#' + text)\n        self.headindex += 1\n        \n    def add_parameter(self, name, value):\n        \"\"\"\n        add a parameter to the comment section\n        \"\"\"\n        cmd = '\\ {} = {} '.format(name, value)\n        self.add_header_comment(cmd)\n        \n    def save(self, file = None):\n        \"\"\"\n\n        Save the current datafile. \n\n        With the keyword: *file* = 'new_file'\n\n        the datafile will be written into the new_file name\n\n        \"\"\"\n        if file == None:\n            o = open(self.filename,'w')\n        else:\n            o = open( file, 'w')\n        self.write_all(o, complete_header = True)\n\n    def make_fmt(self):\n        fmt = ''\n        for k in self.keys[:-1]:\n            fmt += format_dict[self.formats[k]] + ', '\n        return fmt.strip()[:-1]\n\n    def make_csv(self):\n        keys = self.keys[:-1]\n        csv = [ ''.join([k + ',' for k in keys]) ]\n        for l in self.data:\n            fmt = self.make_fmt()\n            data = [l[k] for k in keys]\n            ll = fmt.format(*data)\n            csv.append(ll)\n        return csv\n\n    def write_csv(self, f):\n        \"\"\"\n        \n        save the current file as a csv file\n        \n        f : file name  to be used\n        \n        \"\"\"\n        o = open(f,'w')\n        csv = self.make_csv()\n        for l in csv:\n            o.write(l + '\\n')\n        o.close()\n\n\n#\n", "meta": {"hexsha": "54dc8f809516673f26de55bde6321efcbb89e4d6", "size": 29009, "ext": "py", "lang": "Python", "max_stars_repo_path": "build/lib/LT/datafile.py", "max_stars_repo_name": "boeglinw/LabTools3", "max_stars_repo_head_hexsha": "e05d6a7208eec363c8344f6fdcf395f7df5030fc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "build/lib/LT/datafile.py", "max_issues_repo_name": "boeglinw/LabTools3", "max_issues_repo_head_hexsha": "e05d6a7208eec363c8344f6fdcf395f7df5030fc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "build/lib/LT/datafile.py", "max_forks_repo_name": "boeglinw/LabTools3", "max_forks_repo_head_hexsha": "e05d6a7208eec363c8344f6fdcf395f7df5030fc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.2934196332, "max_line_length": 112, "alphanum_fraction": 0.5031541935, "include": true, "reason": "import numpy", "num_tokens": 6558, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4073334000459302, "lm_q2_score": 0.1460872489071524, "lm_q1q2_score": 0.059506215800706495}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     formats: ipynb,py:percent\n#     notebook_metadata_filter: all\n#     text_representation:\n#       extension: .py\n#       format_name: percent\n#       format_version: '1.2'\n#       jupytext_version: 1.2.3\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n#   language_info:\n#     codemirror_mode:\n#       name: ipython\n#       version: 3\n#     file_extension: .py\n#     mimetype: text/x-python\n#     name: python\n#     nbconvert_exporter: python\n#     pygments_lexer: ipython3\n#     version: 3.7.6\n# ---\n\n# %% [markdown]\n# # ConsPortfolioModel Documentation\n#\n# [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/econ-ark/DemARK/master?filepath=notebooks%2FConsPortfolioModelDoc.ipynb)\n\n# %% {\"code_folding\": []}\n# Setup stuff\n\nimport HARK.ConsumptionSaving.ConsPortfolioModel as cpm\nimport HARK.ConsumptionSaving.ConsumerParameters as param\nimport copy\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport warnings\nwarnings.filterwarnings('ignore')\nfrom HARK.ConsumptionSaving.ConsPortfolioModel import PortfolioSolution\n\n# %% [markdown]\n# We implement three different ways to allow portfolio choice.\n#            The agent can choose \n#               * any portfolio share ('continuous choice')\n#               * only a specified set of portfolio shares ('discrete choice')\n#                 * With probability 1 (agent always gets to choose)\n#                 * With probability 0 < p < 1 (stochastic chance to choose)\n#         \n#            We allow two choices for the description of the \n#            distribution of the stochastic variable:\n#            1. A generic discrete probability distribution\n#               * Nodes and their probabilities are specified\n#            2. A true lognormal distribution\n#               * The mean return and the standard deviation are specified\n#         \n#            In the discrete portfolio shares case, the user also must\n#            input a function that *draws* from the distribution in drawRiskyFunc\n#\n#            Other assumptions: \n#               * distributions are time constant\n#               * probability of being allowed to reoptimize is time constant\n#                  * If p < 1, you must specify the PortfolioSet discretely\n#         \n\n# %% {\"code_folding\": []}\n# Set up the model\n# Parameters from Mehra and Prescott (1985):\nAvg = 1.08 # equity premium \nStd = 0.20 # standard deviation of rate-of-return shocks \n\nRiskyDstnFunc = cpm.RiskyDstnFactory(RiskyAvg=Avg, RiskyStd=Std)       # Generates nodes for integration\nRiskyDrawFunc = cpm.LogNormalRiskyDstnDraw(RiskyAvg=Avg, RiskyStd=Std) # Function to generate draws from a lognormal distribution\n\ninit_portfolio = copy.copy(param.init_idiosyncratic_shocks) # Default parameter values for inf horiz model - including labor income with transitory and permanent shocks\ninit_portfolio['approxRiskyDstn'] = RiskyDstnFunc\ninit_portfolio['drawRiskyFunc']   = RiskyDrawFunc\ninit_portfolio['RiskyCount']      = 2   # Number of points in the approximation; 2 points is minimum\ninit_portfolio['RiskyShareCount'] = 25  # How many discrete points to allow for portfolio share\ninit_portfolio['Rfree']           = 1.0 # Riskfree return factor (interest rate is zero)\ninit_portfolio['CRRA']            = 6.0 # Relative risk aversion\n\n# Uninteresting technical parameters:\ninit_portfolio['aXtraMax']        = 100 \ninit_portfolio['aXtraCount']      = 50\ninit_portfolio['BoroCnstArt']     = 0.0 # important for theoretical reasons\n# init_portfolio['vFuncBool'] = True # We do not need value function for purposes here\n\ninit_portfolio['DiscFac'] = 0.92 # Make them impatient even wrt a riskfree return of 1.08 \n\n# Create portfolio choice consumer type\npcct = cpm.PortfolioConsumerType(**init_portfolio)\n\n# %% {\"code_folding\": []}\n# Solve the model under the given parameters\n\npcct.solve()\naMin = 0   # Minimum ratio of assets to income to plot\naMax = 10  # Maximum ratio of assets to income to plot\naPts = 100 # Number of points to plot \n\n# Campbell-Viceira (2002) approximation to optimal portfolio share in Merton-Samuelson (1969) model\npcct.MertSamCampVicShare = pcct.RiskyShareLimitFunc(RiskyDstnFunc(init_portfolio['RiskyCount']))\n\n# Define grid of points on which to plot\neevalgrid = np.linspace(0,aMax,aPts) # range of values of assets for the plot\n\n# Plot portfolio share by wealth-to-income ratio\nplt.plot(eevalgrid, pcct.solution[0].RiskyShareFunc[0][0](eevalgrid))\nplt.axhline(pcct.MertSamCampVicShare, c='r') # The Campbell-Viceira approximation\nplt.ylim(0,1.05)\nplt.text((aMax-aMin)/4,0.45,r'$\\uparrow $ limit as  $m \\uparrow \\infty$',fontsize = 22,fontweight='bold')\nplt.show()\n\n# %% {\"code_folding\": [0]}\n# Simulate 20 years of behavior for a set of consumers initially distributed widely\nSimPer = 20\n\npcct.track_vars = ['aNrmNow', 't_age', 'RiskyShareNow']\npcct.T_sim = SimPer\npcct.initializeSim()\npcct.simulate()\npcct.RiskyShareNow_hist\n\nfrom mpl_toolkits.mplot3d import Axes3D\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.set_zlim(pcct.MertSamCampVicShare,1.0)\nax.scatter(pcct.aNrmNow_hist, pcct.t_age_hist, pcct.RiskyShareNow_hist)\nplt.show()\n\n# The consumers are impatient and so even if they start rich they end up as buffer stock savers\n# But with all of their buffer stock savings in the stock market\n\n# %%\n# Solve the specialized / simple version for which Campbell-Viceira (2002) is a good approximation\n# (as wealth approaches infinity)\n# This is the version for which Campbell and Viceira provide an approximate formula\n# assuming lognormally distributed shocks\n\ninit_lognormportfolio = copy.deepcopy(init_portfolio) # Use same parameter values\ninit_lognormportfolio['RiskyAvg']   = Avg\ninit_lognormportfolio['RiskyStd']   = Std\ninit_lognormportfolio['RiskyCount'] = 11 # Eleven is enough points to do justice to the distribution\nlnpcct = cpm.LogNormalPortfolioConsumerType(**init_lognormportfolio)\n\nlnpcct.solve()\nlnpcct.MertSamCampVicShare = lnpcct.RiskyShareLimitFunc(RiskyDstnFunc(init_portfolio['RiskyCount']))\n\nfig = plt.figure()\nplt.plot(eevalgrid, lnpcct.solution[0].RiskyShareFunc[0][0](eevalgrid))\nplt.axhline(lnpcct.MertSamCampVicShare, c='r')\nplt.ylim(0,1.05)\nplt.text((aMax-aMin)/4,lnpcct.MertSamCampVicShare-0.1,r'$\\uparrow $ limit as  $m \\uparrow \\infty$',fontsize = 22,fontweight='bold')\nplt.show()\n\n# %%\n# Again simulate a few periods -- similar results (poor buffer stock savers put all their money in the stock market)\nlnpcct.track_vars = ['aNrmNow', 't_age', 'RiskyShareNow']\nlnpcct.T_sim = SimPer\nlnpcct.initializeSim()\nlnpcct.simulate()\nlnpcct.RiskyShareNow_hist\n\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.scatter(lnpcct.aNrmNow_hist, lnpcct.t_age_hist, lnpcct.RiskyShareNow_hist)\nax.set_zlim(lnpcct.MertSamCampVicShare,1.0)\nplt.show()\n\n# %%\n# Version where only discrete values of portfolio share of risky assets are allowed\n\ninit_portfolio_prb = copy.deepcopy(init_portfolio)\n\ninit_portfolio_prb['AdjustPrb'] = 1.0\ninit_portfolio_prb['PortfolioDomain'] = cpm.DiscreteDomain([0.0, 0.5, 0.6, 1.0])\npcct_prb = cpm.PortfolioConsumerType(**init_portfolio_prb)\npcct_prb.solve()\n\neevalgrid = np.linspace(0,100,100)\nplt.plot(eevalgrid, pcct_prb.solution[0].RiskyShareFunc[0][0](eevalgrid))\nplt.axhline(pcct_prb.RiskyShareLimitFunc(RiskyDstnFunc(init_portfolio['RiskyCount'])), c='r')\nplt.ylim(0,1.05)\nplt.show()\n\n\n# %%\n# Version where you can choose your portfolio share only with some 0 < p < 1\n\ninit_portfolio_prb = copy.deepcopy(init_portfolio)\n\ninit_portfolio_prb['AdjustPrb'] = 0.5\ninit_portfolio_prb['PortfolioDomain'] = cpm.DiscreteDomain([0.0, 0.6, 1.0])\npcct_prb = cpm.PortfolioConsumerType(**init_portfolio_prb)\n\npcct_prb.solve()\n\nplt.plot(eevalgrid, pcct_prb.solution[0].RiskyShareFunc[0][0](eevalgrid))\nplt.show()\n\npcct_prb.track_vars = ['aNrmNow', 't_age', 'RiskyShareNow', 'CantAdjust']\npcct_prb.T_sim = 10\npcct_prb.AgentCount = 30\npcct_prb.initializeSim()\npcct_prb.simulate()\npcct_prb.RiskyShareNow_hist\n\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.scatter(pcct_prb.aNrmNow_hist, pcct_prb.t_age_hist, pcct_prb.RiskyShareNow_hist)\nplt.show()\n", "meta": {"hexsha": "369a32b6dffde549be04f5d21baf1a0f09d3ad5a", "size": 8170, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks/ConsPortfolioModelDoc.py", "max_stars_repo_name": "frankovici/DemARK", "max_stars_repo_head_hexsha": "177c09bd387160d06f979c417671b3de18746846", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/ConsPortfolioModelDoc.py", "max_issues_repo_name": "frankovici/DemARK", "max_issues_repo_head_hexsha": "177c09bd387160d06f979c417671b3de18746846", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "notebooks/ConsPortfolioModelDoc.py", "max_forks_repo_name": "frankovici/DemARK", "max_forks_repo_head_hexsha": "177c09bd387160d06f979c417671b3de18746846", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.0, "max_line_length": 168, "alphanum_fraction": 0.7328029376, "include": true, "reason": "import numpy", "num_tokens": 2278, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4921881357207956, "lm_q2_score": 0.12085322932404165, "lm_q1q2_score": 0.05948252563683785}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Handwritten mathematical sumbols\n\n# ## Data preprocessing\n\n# Hand_written\n#     \n#     --> handwritten_mathematical_model.ipynb\n#     --> hasy-data\n#     --> hasy-data-labels\n#     --> symbols.csv\n#     --> hasyv2\n#         --> hasy-data\n#         --> hasy-data-labels\n#         --> symbols.csv\n#         --> verification-task\n#     --> verification-task\n#     \n# Note:- You can use hasyv2 but for this I have not used that\n\n#Just to check\nfrom IPython.display import Image\nImage(url='hasy-data/v2-00010.png')\n\n#importing libraries for preprocessing task\nimport csv\nfrom PIL import Image as pil_image\nimport keras.preprocessing.image\n\n#load all images and save there classes\n\nimgs = []\nclasses = []\nwith open('hasy-data-labels.csv') as csvFile:\n    csvReader = csv.reader(csvFile)\n    i = 0\n    for row in csvReader:\n        if i > 0:\n            img = keras.preprocessing.image.img_to_array(pil_image.open(row[0]))\n            img /= 255.0\n            imgs.append((row[0], row[2], img))\n            classes.append(row[2])\n        i += 1\nprint(\"Total number of images: \", len(imgs)) #print the total number of images \n\n\n# Randomly split the data into training and test\n# \n# 80% -> train\n# \n# 20% -> test\n\nimport random\nrandom.shuffle(imgs)\nsplit_idx = int(0.8*len(imgs))\ntrain = imgs[:split_idx]\ntest = imgs[split_idx:]\n\n#Later take 20% from train for validation\n\nimport numpy as np\n\ntrain_input = np.asarray(list(map(lambda row: row[2], train)))\ntest_input = np.asarray(list(map(lambda row: row[2], test)))\n\ntrain_output = np.asarray(list(map(lambda row: row[1], train)))\ntest_output = np.asarray(list(map(lambda row: row[1], test)))\n\n\n# learn about oneHotEncoder\n# https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html\n#our labels are in the text format therefore using oneHotEncoder to convert them\n    \nfrom sklearn.preprocessing import LabelEncoder, OneHotEncoder\n\nlabel_encoder = LabelEncoder()\ninteger_encoded = label_encoder.fit_transform(classes)\n\nonehot_encoder = OneHotEncoder(sparse = False)\ninteger_encoded = integer_encoded.reshape(len(integer_encoded), 1)\nonehot_encoder.fit(integer_encoded)\n\ntrain_output_int = label_encoder.transform(train_output)\ntrain_output = onehot_encoder.transform(train_output_int.reshape(len(train_output_int), 1))\ntest_output_int = label_encoder.transform(test_output)\ntest_ouput = onehot_encoder.transform(test_output_int.reshape(len(test_output_int), 1))\n\nnum_classes = len(label_encoder.classes_)\n\nprint(\"Number of classes\", num_classes)\nprint(\"Shape of the input image: \", np.shape(train_input[0]))\n\n\n# ## Model\n\n#importing libraries\n\nimport tensorflow as tf\nfrom tensorflow import keras\nfrom tensorflow.keras.models import Sequential\nfrom tensorflow.keras.optimizers import RMSprop, Adam\nfrom tensorflow.keras.layers import (\n    Dense,\n    Dropout,\n    Flatten,\n    Conv2D,\n    MaxPooling2D\n)\n\n\n# This is very basic CNN architecture with some convolution layer followed by max pooling layer\n# which is then followed by flatten and some dense layer.\n\n#model architecture\n\nmodel = Sequential([\n    Conv2D(32, (3,3), activation='relu', input_shape = np.shape(train_input[0])),\n    MaxPooling2D(pool_size = (2,2)),\n    Conv2D(32, (3,3), activation='relu'),\n    MaxPooling2D(pool_size = (2,2)),\n    Flatten(),\n    Dense(1024, activation = 'tanh'),\n    Dropout(0.5),  #to reduce overfitting\n    Dense(num_classes, activation='softmax')\n])\n\n#compile model\nlearning_rate = 1e-5 #1e-2 (0.01)\n\nmodel.compile(\n            optimizer = 'adam', #Adam(lr = learning_rate)\n            loss = 'categorical_crossentropy', \n            metrics = ['accuracy'])\n\n\nmodel.summary()\n\n\n# Training\nBATCH_SIZE = 32\nEPOCHS = 15 #10\nVALIDATION_SPLIT = 0.2\n\nhistory = model.fit(train_input, train_output,\n                   batch_size = BATCH_SIZE,\n                   epochs = EPOCHS,\n                   verbose = 1,\n                   validation_split = VALIDATION_SPLIT)\n\n#Accuracy I achieved was nearly 82% after 10th epoch (Val_accuracy -> 77%) \n#tuning hyparameters and changing model architecture will help you gain much more accuracy and reduce overfitting\n\n\n# Plotting the graphs: \n#     1. Training and validation accuracy\n#     2. Training and validation loss\n\nimport matplotlib.pyplot as plt\n\nacc = history.history['accuracy']\nval_acc = history.history['val_accuracy']\nloss = history.history['loss']\nval_loss = history.history['val_loss']\n\nepochs = range(len(acc))\n\nfig = plt.subplots(figsize=(30, 10))\n\nplt.subplot(1, 2, 1)\nplt.plot(acc)\nplt.plot(val_acc)\nplt.title('Training and Validation Accuracy')\nplt.xlabel('Epoch')\nplt.ylabel('Accuracy')\nplt.legend(['Training Accuracy', 'Validation Accuracy'])\n\nplt.subplot(1, 2, 2)\nplt.plot(loss)\nplt.plot(val_loss)\nplt.title('Training and Validation Loss')\nplt.xlabel('Epoch')\nplt.ylabel('Loss')\nplt.legend(['Training Loss', 'Validation Loss'])\n\nplt.show()\n\n\n# ## Saving model\nmodel.save('mathSymbolsPredictor.model')\nnp.save('classes.npy', label_encoder.classes_)\n\n\n# ## New predictions\n\nimport keras.models\n#model_ = keras.models.load('mathSymbolsPredictor.model')\n\nlabel_encoder2 = LabelEncoder()\nlabel_encoder2.classes_ = np.load('classes.npy')\n\nPATH = 'hasy-data/v2-00100.png'\n\nimage = keras.preprocessing.image.img_to_array(pil_image.open(PATH))\nimage /= 255.\npredicted = (model.predict(image.reshape(1, 32, 32, 3)))\ninverted = label_encoder2.inverse_transform([np.argmax(predicted)])\nprint(inverted[0], np.max(predicted))\n(Image(url=PATH))\n\n# # Convert your model into .tflite \n# ## To deploy it on an application\n\nRPS_SAVED_MODEL = \"rps_saved_model\"\ntf.saved_model.save(model, RPS_SAVED_MODEL)\n\nget_ipython().run_cell_magic('bash', '-s $RPS_SAVED_MODEL', 'saved_model_cli show --dir $1 --tag_set serve --signature_def serving_default')\n\nloaded = tf.saved_model.load(RPS_SAVED_MODEL)\nprint(list(loaded.signatures.keys()))\ninfer = loaded.signatures[\"serving_default\"]\nprint(infer.structured_input_signature)\nprint(infer.structured_outputs)\nconverter = tf.lite.TFLiteConverter.from_saved_model(RPS_SAVED_MODEL)\nconverter.optimizations = [tf.lite.Optimize.OPTIMIZE_FOR_SIZE]\ntflite_model = converter.convert()\n\nimport tensorflow as tf\ntflite_model_file = 'handwritten_mathematical_symbol_model_v1.tflite'\n\n\n\n\n\n\n\n", "meta": {"hexsha": "ac10ba251aa4e8b494b28f11429bf853895bb380", "size": 6270, "ext": "py", "lang": "Python", "max_stars_repo_path": "handwritten_mathematical_model.py", "max_stars_repo_name": "Yoshibansal/handwritten-mathematical-symbols", "max_stars_repo_head_hexsha": "a305581c1f4a76ca5d4842b8428f673ba8782019", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-09-28T17:55:54.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-28T17:55:54.000Z", "max_issues_repo_path": "handwritten_mathematical_model.py", "max_issues_repo_name": "Yoshibansal/handwritten-mathematical-symbols", "max_issues_repo_head_hexsha": "a305581c1f4a76ca5d4842b8428f673ba8782019", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "handwritten_mathematical_model.py", "max_forks_repo_name": "Yoshibansal/handwritten-mathematical-symbols", "max_forks_repo_head_hexsha": "a305581c1f4a76ca5d4842b8428f673ba8782019", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.3445378151, "max_line_length": 140, "alphanum_fraction": 0.719138756, "include": true, "reason": "import numpy", "num_tokens": 1549, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.11920292045759122, "lm_q1q2_score": 0.05913583329392384}}
{"text": "import os\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom saf.euler1d.linear.asciireader import ASCIIReader\n\nfrom helpers import FIGSIZE_SIX_SUBPLOTS as figsize, savefig\n\n# ---\n# ## Helper functions\n\n# In[2]:\n\ndef znd_read_data():\n    output_dir = '_output'\n    dirs = os.listdir(output_dir)\n    dirs.sort()\n    \n    x = []\n    rho = []\n    u = []\n    p = []\n    lamda = []\n\n    for d in dirs:\n        dirname = os.path.join(output_dir, d)\n\n        r = ASCIIReader(dirname)\n\n        znd_data = r.get_znd_data()\n        x.append(znd_data['x'])\n        rho.append((d, znd_data['rho']))\n        u.append((d, znd_data['u_lab']))\n        p.append((d, znd_data['p']))\n        lamda.append((d, znd_data['lamda']))\n        \n    return x, rho, u, p, lamda\n\n\ndef _znd_plot_quantity(x, quantity, axis, k):\n    line_styles = ['-', '--', ':', '-o', '-*']\n    assert k >= 0\n    assert k < len(line_styles)\n    if k != 3 and k != 4:\n        axis.plot(x, quantity, line_styles[k])\n    else:\n        ls = line_styles[k]\n        s1 = ls[0]\n        s2 = ls[1]\n        R = 10\n        line, = axis.plot(x, quantity, s1)\n        color = line.get_color()\n        axis.plot(x[::R], quantity[::R], s2, color=color, markeredgecolor=color)\n\n\ndef znd_plot_data(x, rho, u, p, lamda):\n    # Number of rows and columns in figures\n    m, n = 3, 2\n    E_ACT = 30.0\n    X_LIM = -8\n    \n    fig, axes = plt.subplots(nrows=m, ncols=n, figsize=figsize)\n\n    assert len(x) == len(rho)\n    assert len(x) == len(u)\n    assert len(x) == len(p)\n    assert len(x) == len(lamda)\n\n    # Density\n    ax = axes[0, 0]\n    for k, __ in enumerate(rho):\n        cur_x = x[k]\n        cur_rho = rho[k][1]\n        cur_rho = cur_rho/cur_rho[-1]\n\n        _znd_plot_quantity(cur_x, cur_rho, ax, k)\n    ax.set_ylabel(r'$\\bar{\\rho}/\\bar{\\rho}_{\\mathrm{s}}$')\n    ax.set_xlabel(r'$x$')\n    ax.set_xlim((X_LIM, 0))\n    ax.set_yticks([0.0, 0.2, 0.4, 0.6, 0.8, 1.0])\n    ax.set_ylim((0, 1.0))\n        \n    # Progress variable\n    ax = axes[0, 1]\n    for k, __ in enumerate(lamda):\n        cur_x = x[k]\n        cur_lamda = lamda[k][1]\n\n        _znd_plot_quantity(cur_x, cur_lamda, ax, k)\n    ax.set_ylabel(r'$\\bar{\\lambda}$')\n    ax.set_xlabel(r'$x$')\n    ax.set_xlim((X_LIM, 0))\n    ax.set_ylim((0, 1.0))\n            \n    # Pressure\n    ax = axes[1, 0]\n    for k, __ in enumerate(p):\n        cur_x = x[k]\n        cur_p = p[k][1]\n        cur_p = cur_p/cur_p[-1]\n\n        _znd_plot_quantity(cur_x, cur_p, ax, k)\n    ax.set_ylabel(r'$\\bar{p}/\\bar{p}_{\\mathrm{s}}$')\n    ax.set_xlabel(r'$x$')\n    ax.set_xlim((X_LIM, 0))\n    ax.set_ylim((0.5, 1.0))\n        \n    # Velocity\n    ax = axes[1, 1]\n    for k, __ in enumerate(u):\n        cur_x = x[k]\n        cur_label = u[k][0]\n        cur_u = u[k][1]\n        cur_u = cur_u/cur_u[-1]\n\n        _znd_plot_quantity(cur_x, cur_u, ax, k)\n    ax.set_ylabel(r'$\\bar{u}/\\bar{u}_{\\mathrm{s}}$')\n    ax.set_xlabel(r'$x$')\n    ax.set_xlim((X_LIM, 0))\n    ax.set_ylim((0.5, 1.0))\n        \n    # Temperature\n    ax = axes[2, 0]\n    for k, __ in enumerate(p):\n        cur_x = x[k]\n        cur_p = p[k][1]\n        cur_p = cur_p / cur_p[-1]\n        cur_rho = rho[k][1]\n        cur_rho = cur_rho / cur_rho[-1]\n        cur_T = cur_p / cur_rho\n\n        _znd_plot_quantity(cur_x, cur_T, ax, k)\n    ax.set_ylabel(r'$\\bar{T}/\\bar{T}_{\\mathrm{s}}$')\n    ax.set_xlabel(r'$x$')\n    ax.set_xlim((X_LIM, 0))\n    ax.set_ylim((0.95, 2.8))\n        \n    # Reaction rate\n    ax = axes[2, 1]\n    for k, __ in enumerate(p):\n        cur_x = x[k]\n        cur_p = p[k][1]\n        cur_rho = rho[k][1]\n        cur_lamda = lamda[k][1]\n        r = (1 - cur_lamda) * np.exp(-E_ACT*cur_rho/(cur_p))\n        r = r / np.max(r)\n\n        _znd_plot_quantity(cur_x, r, ax, k)\n    ax.set_ylabel(r'$\\bar{\\omega}/\\bar{\\omega}_{\\mathrm{max}}$')\n    ax.set_xlabel(r'$x$')\n    ax.set_xlim((X_LIM, 0))\n    ax.set_ylim((0, 1.0))\n        \n    fig.tight_layout(pad=0.1, h_pad=0.55)\n    savefig('znd-solutions.pdf')\n\n\n# ---\n# ## Reading data\n\n# In[3]:\n\nx, rho, u, p, lamda = znd_read_data()\n\n\n# ---\n# ## Plotting ZND solutions\n\n# The figure below contains profiles of different quantities of ZND solution.\n# Solid lines is for $Q=0.5$, dashed line is for $Q=1.0$, dotted line is for $Q=10$, solid line with circle marker is for $Q=50$, solid line with star marker is for $Q=100$.\n\n# In[4]:\n\nznd_plot_data(x, rho, u, p, lamda)\n", "meta": {"hexsha": "59708d96404fe2a6bc302d07dd69cf0e39c6ca50", "size": 4354, "ext": "py", "lang": "Python", "max_stars_repo_path": "znd-solutions/plot-znd-solutions.py", "max_stars_repo_name": "dmitry-kabanov/euler1d-reproducibility", "max_stars_repo_head_hexsha": "b54bc1e229e15abe4190f451e266eba1ba6cdd75", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "znd-solutions/plot-znd-solutions.py", "max_issues_repo_name": "dmitry-kabanov/euler1d-reproducibility", "max_issues_repo_head_hexsha": "b54bc1e229e15abe4190f451e266eba1ba6cdd75", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "znd-solutions/plot-znd-solutions.py", "max_forks_repo_name": "dmitry-kabanov/euler1d-reproducibility", "max_forks_repo_head_hexsha": "b54bc1e229e15abe4190f451e266eba1ba6cdd75", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.7386363636, "max_line_length": 173, "alphanum_fraction": 0.5418006431, "include": true, "reason": "import numpy", "num_tokens": 1472, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4882833952958347, "lm_q2_score": 0.12085324040654355, "lm_q1q2_score": 0.05901063055821085}}
{"text": "\n# coding: utf-8\n\n# # Anomalies in meal prices\n# \n# In the Chamber of Deputies' CEAP, there is a list of 1,000's of meal expenses made by congresspeople. The law says that the congressperson cannot pay for any other, even being her advisor or SO. We want to work on this analysis to find possibly illegal and immoral expenses. They may have happened when the politician spent more than needed (e.g. the whole menu costs X but the bill was 2X) or too much in an specific period of time. In the end, we also want to alert about too expensive reibursements, even with an explanation behind of it.\n# \n# Note: remember to correct prices with an inflation index (e.g. IPCA).\n\n# In[1]:\n\nget_ipython().magic('matplotlib inline')\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nsns.set(color_codes=True)\n\nplt.rcParams['figure.figsize'] = (20, 10)\n\n\n# In[2]:\n\nfrom serenata_toolbox.datasets import fetch\n\nfetch('2016-11-19-reimbursements.xz', '../data')\nfetch('2016-09-03-companies.xz', '../data')\nfetch('2016-11-29-yelp-companies.xz', '../data')\nfetch('2016-12-02-foursquare-companies.xz', '../data')\n\n\n# In[3]:\n\nimport numpy as np\nimport pandas as pd\n\ndataset = pd.read_csv('../data/2016-11-19-reimbursements.xz',\n                      dtype={'applicant_id': np.str,\n                             'cnpj_cpf': np.str,\n                             'congressperson_id': np.str,\n                             'subquota_number': np.str},\n                      low_memory=False)\ndataset = dataset[dataset['congressperson_id'].notnull()]\ndataset['issue_date'] = pd.to_datetime(dataset['issue_date'], errors='coerce')\ndataset['issue_date_day'] = dataset['issue_date'].apply(lambda date: date.day)\ndataset['issue_date_month'] = dataset['issue_date'].apply(lambda date: date.month)\ndataset['issue_date_year'] = dataset['issue_date'].apply(lambda date: date.year)\ndataset['issue_date_weekday'] = dataset['issue_date'].apply(lambda date: date.weekday())\ndataset['issue_date_week'] = dataset['issue_date'].apply(lambda date: date.week)\n\n\n# The `companies.xz` dataset has businesses placed outside Brazilian area. We intentionally disconsider them.\n\n# In[4]:\n\nis_in_brazil = '(-73.992222 < longitude < -34.7916667) & (-33.742222 < latitude < 5.2722222)'\ncompanies = pd.read_csv('../data/2016-09-03-companies.xz',\n                        dtype={'cnpj': np.str},\n                        low_memory=False)\ncompanies = companies.query(is_in_brazil)\ncompanies['cnpj'] = companies['cnpj'].str.replace(r'\\D', '')\ndataset = pd.merge(dataset, companies,\n                   how='left',\n                   left_on='cnpj_cpf',\n                   right_on='cnpj',\n                   suffixes=('', '_company'))\n\n\n# In[5]:\n\ndataset =     dataset.query('subquota_description == \"Congressperson meal\"')\ncompanies =     companies[companies['cnpj'].isin(dataset.loc[dataset['cnpj'].notnull(),\n                                                 'cnpj'])]\n\n\n# In[6]:\n\ndataset['total_net_value'].describe()\n\n\n# In[7]:\n\ndataset['total_net_value'].median()\n\n\n# In[8]:\n\nsns.distplot(dataset['total_net_value'],\n             bins=30,\n             kde=False)\n\n\n# In[9]:\n\nbottom_99 = dataset['total_net_value'].quantile(0.99)\nbottom_99\n\n\n# In[10]:\n\ndataset[dataset['total_net_value'] < bottom_99].shape\n\n\n# In[11]:\n\nsns.distplot(dataset.loc[dataset['total_net_value'] < bottom_99, 'total_net_value'],\n             bins=30,\n             kde=False)\n\n\n# In[12]:\n\nbottom_99_dataset = dataset.query('total_net_value > {}'.format(bottom_99))\nranking = bottom_99_dataset.groupby('state_company')['total_net_value']     .median().sort_values(ascending=False)\n\nsns.boxplot(x='state_company',\n            y='total_net_value',\n            data=bottom_99_dataset,\n            order=ranking.index)\n\n\n# In[13]:\n\nbottom_99_dataset.query('state_company == \"CE\"').shape\n\n\n# In[14]:\n\ndataset.query('state_company == \"CE\"').shape\n\n\n# In[15]:\n\nbottom_99_dataset['state_company'].isnull().sum()\n\n\n# In[16]:\n\nbottom_99_dataset.query('state_company == \"CE\"')     .sort_values('total_net_value', ascending=False)\n\n\n# ## Using Yelp to improve prices information\n\n# In[17]:\n\nyelp = pd.read_csv('../data/2016-11-29-yelp-companies.xz',\n                   low_memory=False)\nyelp.head()\n\n\n# We have data for just 8.6% of the companies which received from the \"Congressperson meal\" subquota.\n\n# In[18]:\n\nyelp['price'].notnull().sum()\n\n\n# In[19]:\n\ncompanies.shape\n\n\n# In[20]:\n\nyelp['price'].isnull().sum()\n\n\n# In[21]:\n\nyelp['price.int'] = yelp['price'].str.len()\nstates_with_records =     yelp[yelp['price'].notnull()].groupby('location.state')['location.state'].count() > 10\nstates_with_records = states_with_records[states_with_records].index\n\n\n# In[22]:\n\nyelp_just_significant_states =     yelp[yelp['price'].notnull() &\n         yelp['location.state'].isin(states_with_records)]\nyelp_just_significant_states['location.state'].value_counts()\n\n\n# Yelp won't be that useful for now, since we don't have a lot of data. Will leave it for another analysis.\n\n# ## Predict prices\n\n# The idea here is to try to predict the \"right range for prices\" in a specific place. If we can have a good accuracy, everything far from the prediction could be considered an outlier.\n\n# In[23]:\n\nbottom_99_dataset.iloc[0, :57]\n\n\n# **DummyRegressor with mean strategy as a baseline**\n\n# In[24]:\n\nfrom sklearn.dummy import DummyRegressor\nfrom sklearn.model_selection import train_test_split\n\nX = bottom_99_dataset[['year']]\ny = bottom_99_dataset['total_net_value']\nX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)\n\nmodel = DummyRegressor(strategy='mean')\nmodel.fit(X_train, y_train)\nmodel.score(X_test, y_test)\n\n\n# In[25]:\n\nfrom sklearn.preprocessing import LabelEncoder\n\nle_state = LabelEncoder()\nle_city = LabelEncoder()\nfactor_columns = ['state_company', 'city']\nmodel_dataset = bottom_99_dataset.dropna(subset=factor_columns)\nmodel_dataset['state_company'] = le_state.fit_transform(model_dataset['state_company'])\nmodel_dataset['city'] = le_city.fit_transform(model_dataset['city'])\n\nmodel_columns = ['cnpj',\n                 'issue_date_day',\n                 'issue_date_month',\n                 'issue_date_year']\nX = model_dataset[model_columns + factor_columns]\ny = model_dataset['total_net_value']\nX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)\n\n\n# **LinearRegression**\n# \n# Not very good accuracy.\n\n# In[26]:\n\nfrom sklearn.linear_model import LinearRegression\n\nmodel = LinearRegression(n_jobs=-1)\nmodel.fit(X_train, y_train)\nmodel.score(X_test, y_test)\n\n\n# What if we could improve it using the type of business as a feature? e.g. restaurant, hotel, grill...\n\n# In[27]:\n\nimport unicodedata\n\ndef normalize_string(string):\n    if isinstance(string, str):\n        nfkd_form = unicodedata.normalize('NFKD', string.lower())\n        return nfkd_form.encode('ASCII', 'ignore').decode('utf-8')\n\n\n# In[28]:\n\nimport nltk\nfrom sklearn.feature_extraction.text import CountVectorizer\n\nstopwords = nltk.corpus.stopwords.words('portuguese')\ncount_vect = CountVectorizer(stop_words=stopwords)\ntrade_names = dataset.loc[dataset['supplier'].notnull(),\n                          'supplier'].unique()\ntrade_names = np.vectorize(normalize_string)(trade_names)\ndataset_counts = count_vect.fit_transform(trade_names)\n\n\n# In[29]:\n\nfrequent_words = sorted(list(zip(count_vect.get_feature_names(),\n    np.asarray(dataset_counts.sum(axis=0)).ravel())), key=lambda x: -x[1])\n\n\n# In[30]:\n\nfrequent_words[:20]\n\n\n# In[31]:\n\nfrequent_words = dict(frequent_words)\n\nexcluded_keywords = ['ltda', 'cia', 'epp']\n[frequent_words.pop(keyword) for keyword in excluded_keywords]\n\n\n# In[32]:\n\ndef business_type(name):\n    fun = np.vectorize(lambda x: normalize_string(x))\n    keywords = set(fun(name.split(' '))) - set(stopwords)\n    key_freqs = list(map(lambda x: (x, frequent_words.get(x)), list(keywords)))\n    key_freqs = [key_freq for key_freq in key_freqs if key_freq[1] is not None]\n    if key_freqs:\n        key_freq = max(key_freqs, key=lambda x: x[1])\n        return key_freq[0]\n\ndataset['supplier_keyword'] = dataset['supplier'].apply(business_type)\nbottom_99_dataset['supplier_keyword'] =     bottom_99_dataset['supplier'].apply(business_type)\n\n\n# In[33]:\n\nle_state = LabelEncoder()\nle_city = LabelEncoder()\nle_supplier_keyword = LabelEncoder()\nfactor_columns = ['state_company', 'supplier_keyword']\nmodel_dataset = bottom_99_dataset.dropna(subset=factor_columns)\nmodel_dataset['state_company'] = le_state.fit_transform(model_dataset['state_company'])\nmodel_dataset['city'] = le_city.fit_transform(model_dataset['city'])\nmodel_dataset['supplier_keyword'] = le_city.fit_transform(model_dataset['supplier_keyword'])\n\nmodel_columns = ['cnpj',\n                 'issue_date_day',\n                 'issue_date_month',\n                 'issue_date_year']\nX = model_dataset[model_columns + factor_columns]\ny = model_dataset['total_net_value']\nX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)\n\n\n# In[34]:\n\nmodel = LinearRegression(n_jobs=-1)\nmodel.fit(X_train, y_train)\nmodel.score(X_test, y_test)\n\n\n# Still not good enough. In fact, there's a serious mistake when considering this linear regression method for outlier detection: not just we're assuming that prices follow a linear regression (IMHO still good assumption, though), but outliers should be removed before running the regression. In other words, to find outliers, we must first remove them, having the regression score as just a accuracy estimator. May still be an interesting approach but we want to engage with something simpler first, to get the easier and most anomalous results.\n\n# ## Common CNPJs\n# \n# Expenses in the same restaurant are expected to follow a normal distribution. Can we find outliers in companies with enough expenses to analyze?\n\n# In[35]:\n\nfrom scipy.stats import normaltest\n\ndef normaltest_pvalue(values):\n    if len(values) >= 20:\n        return normaltest(values).pvalue\n    else:\n        return 1\n\nnet_values_by_cnpj = dataset.groupby('cnpj_cpf')['total_net_value']     .agg([len, np.mean, np.std, normaltest_pvalue])     .sort_values('len', ascending=False)     .reset_index()\nnet_values_by_cnpj['threshold'] = net_values_by_cnpj['mean'] +     3 * net_values_by_cnpj['std']\napplicants_per_cnpj = dataset.groupby('cnpj_cpf')['applicant_id']     .aggregate(lambda x: len(set(x))).reset_index()     .rename(columns={'applicant_id': 'congresspeople'})\nnet_values_by_cnpj = pd.merge(net_values_by_cnpj, applicants_per_cnpj)\nnet_values_by_cnpj.head()\n\n\n# In[36]:\n\nlen(net_values_by_cnpj.query('normaltest_pvalue < .05')) / len(net_values_by_cnpj)\n\n\n# In[37]:\n\ndata_with_threshold = pd.merge(dataset, net_values_by_cnpj, on='cnpj_cpf')     .sort_values('total_net_value', ascending=False)\n\n\n# In[38]:\n\ndata_with_threshold['main_activity'] =     data_with_threshold['main_activity'].apply(normalize_string)\n\n\n# Let's discard hotel reibursements. There's no method yet to discover for how long the congressperson stayed in the hotel, so we can expect a high standard deviation in their expenses. Even when detecting outliers, it's too hard to investigate manually given the same reason.\n# \n# Here, we just consider CNPJs where we have more than 20 reimbursements, from at least 3 congresspeople.\n\n# In[39]:\n\nis_hotel_reimbursement = data_with_threshold['main_activity']     .str.contains('hoteis').astype(np.bool)\noutliers = data_with_threshold[~is_hotel_reimbursement]     .query('(congresspeople > 3) & (len >= 20) & (total_net_value > threshold)')\nprint(len(outliers), outliers['total_net_value'].sum())\n\n\n# ## Foursquare\n# \n# Before totally discarding it, let's see how significant is the Foursquare dataset.\n\n# In[40]:\n\nfoursquare = pd.read_csv('../data/2016-12-02-foursquare-companies.xz',\n                         low_memory=False)\nfoursquare.head()\n\n\n# In[41]:\n\nfoursquare.iloc[0]\n\n\n# In[42]:\n\nprint(foursquare['price.tier'].notnull().sum(),\n      foursquare['price.tier'].notnull().sum() / len(companies),\n      foursquare.query('confirmed_match == True')['price.tier'].notnull().sum() / len(companies))\n\n\n# ### Clustering for find the best group for a new restaurant\n\n# In[43]:\n\ncompanies.shape\n\n\n# In[44]:\n\n# is_cnpj = (dataset['cnpj_cpf'].str.len() == 14) & \\\n#     dataset['cnpj_cpf'].notnull() & \\\n#     dataset['document_type'] != 2\n# cnpjs = dataset.sort_values('issue_date') \\\n#     .loc[is_cnpj, ['cnpj_cpf', 'supplier']] \\\n#     .drop_duplicates('cnpj_cpf', keep='last')\n# cnpjs.head()\n\n\n# In[45]:\n\nis_cnpj = dataset['cnpj_cpf'].str.len() == 14\ncnpj_list = dataset.loc[is_cnpj].groupby('cnpj')['total_net_value']     .agg([np.mean, np.std]).reset_index()\ncnpj_list.shape\n\n\n# In[46]:\n\ncnpj_list.head()\n\n\n# In[47]:\n\ncnpj_list = pd.merge(cnpj_list,\n                     dataset[['cnpj_cpf', 'supplier']].drop_duplicates('cnpj_cpf'),\n                     how='left',\n                     left_on='cnpj', right_on='cnpj_cpf')\ndel cnpj_list['cnpj_cpf']\ncnpj_list.head()\n\n\n# In[48]:\n\ncounts = dataset.loc[is_cnpj].groupby('cnpj')['applicant_id']     .agg({'congresspeople': (lambda x: len(np.unique(x))),\n          'len': (lambda x: len(x))\n         }).reset_index()\n\ncnpj_list = pd.merge(cnpj_list, counts)\n\n\n# **Calculate threshold for companies using their own receipts**\n\n# In[49]:\n\nthreshold_for_cnpjs = cnpj_list.groupby('cnpj')     .apply(lambda x: x['mean'].mean() + 3 * x['std'].mean()).reset_index()     .rename(columns={0: 'threshold'})\nthreshold_for_cnpjs\n\ncnpj_list = pd.merge(cnpj_list, threshold_for_cnpjs)\ncnpj_list.head()\n\n\n# In[50]:\n\nHOTEL_REGEX = r'hote[l(eis)(ls)]'\nis_hotel_reimbursement = (cnpj_list['supplier'].str.lower().str.contains(HOTEL_REGEX))\n\n\n# Mark companies as having or not significant data.\n\n# In[51]:\n\nrows = (~is_hotel_reimbursement) &     (cnpj_list['congresspeople'] > 3) &     (cnpj_list['len'] > 20)\ncnpj_list['has_significant_data'] = False\ncnpj_list.loc[rows, 'has_significant_data'] = True\n\n\n# In[52]:\n\nprint(cnpj_list['has_significant_data'].sum(),\n      cnpj_list['has_significant_data'].sum() / len(cnpj_list['has_significant_data']))\n\n\n# In[53]:\n\nsns.lmplot('mean', 'std',\n           data=cnpj_list.query('has_significant_data'),\n           scatter_kws={'marker': 'D', 's': 100},\n           size=10)\n\n\n# **Predict threshold classifying companies in clusters by their price ranges**\n\n# In[54]:\n\nX = cnpj_list.loc[cnpj_list['has_significant_data'],\n                  ['mean', 'std']]\n\n\n# In[55]:\n\nfrom sklearn.cluster import KMeans\n\nmodel = KMeans(n_clusters=3, random_state=0)\nmodel.fit(X)\n\n\n# In[56]:\n\ncnpj_list.loc[cnpj_list['has_significant_data'], 'y'] = model.predict(X)\n\n\n# In[57]:\n\ncnpj_list.query('y.notnull()').head()\n\n\n# In[58]:\n\nrows = (~cnpj_list['has_significant_data']) &     cnpj_list['std'].notnull() &     (~is_hotel_reimbursement)\nX = cnpj_list.loc[rows, ['mean', 'std']]\ncnpj_list.loc[rows, 'y'] = model.predict(X)\n\n\n# In[59]:\n\nthreshold_for_groups = cnpj_list.groupby('y')     .apply(lambda x: x['mean'].mean() + 4 * x['std'].mean()).reset_index()     .rename(columns={0: 'threshold'})\nthreshold_for_groups\n\n\n# In[60]:\n\ngroup_thresholds = pd.merge(cnpj_list.query('~has_significant_data'),\n                            threshold_for_groups,\n                            on='y',\n                            suffixes=('', '_group'))\n\ncnpj_list = pd.merge(cnpj_list,\n                     group_thresholds[['cnpj', 'threshold_group']],\n                     how='left')\ncnpj_list.loc[~cnpj_list['has_significant_data'], 'threshold'] =     cnpj_list['threshold_group']\n\n\n# In[61]:\n\ncnpj_list.query('(~has_significant_data) & std.notnull()').head()\n\n\n# In[62]:\n\ncnpj_list.query('has_significant_data').head()\n\n\n# In[63]:\n\ncnpj_list.query('threshold.notnull()').sample(5, random_state=10)\n\n\n# In[64]:\n\ndel cnpj_list['threshold_group']\n\n\n# In[65]:\n\nmerged = pd.merge(dataset, cnpj_list,\n                  how='left',\n                  left_on='cnpj_cpf',\n                  right_on='cnpj',\n                  suffixes=('', '_company'))\n\n\n# In[66]:\n\nmerged['supplier'] = merged['supplier'].astype(np.str)\nis_hotel_reimbursement =     (merged['supplier'].str.lower().str.contains(HOTEL_REGEX))\n\nmerged[~is_hotel_reimbursement].query('total_net_value > threshold').shape\n\n\n# In[67]:\n\nkeys = ['year',\n        'congressperson_name',\n        'document_id',\n        'total_net_value',\n        'threshold',\n        'cnpj_cpf',\n        'has_significant_data',\n        'name']\n\nmerged['diff'] = merged['threshold'] - merged['total_net_value']\nmerged[~(is_hotel_reimbursement | merged['has_significant_data'])]     .query('(total_net_value > threshold)')     .sort_values('diff', ascending=False).head(10)[keys]\n\n\n# In[68]:\n\nmerged[~is_hotel_reimbursement].shape\n\n\n# In[69]:\n\nmerged[~is_hotel_reimbursement]     .query('(total_net_value > threshold)')['total_net_value'].shape\n\n\n# In[70]:\n\nmerged[~is_hotel_reimbursement]     .query('(total_net_value > threshold)')['total_net_value'].sum()\n\n\n# In[71]:\n\nmerged[~is_hotel_reimbursement]     .query('(total_net_value > threshold) & (has_significant_data == False)')['total_net_value'].shape\n\n\n# ## Conclusions\n# \n# For companies with significant data (defined by us as a company which received money at least 20x, from at least 3 distinct congresspeople), we use mean + 3 * std to detect outliers. Does not return all the suspect cases, but all of them, after some sampling investigation, seem to be very suspect.\n# \n# Since there's \"significant data\" just for 4% of the companies, we need a way for extrapolating the results for not so known ones. For doing so, we classify companies in 3 clusters using K-Means, considering mean and standard deviation of their prices as features. Once classified, we consider their threshold mean + 4 * stds of their clusters (one extra std compared to places where we have enough reimbursements to know better).\n# \n# Reimbursements made for expenses in hotels are discarded from this classifier, since they usually contain much more than meals (and we don't know for how long the congressperson was hosted in the place, not yet trustable for legal reports).\n\n# In[ ]:\n\n\n\n", "meta": {"hexsha": "efb4686d78bfc0676244e75477be86c50ccfbd02", "size": 18043, "ext": "py", "lang": "Python", "max_stars_repo_path": "research/develop/2016-12-01-irio-anomalies-in-meal-prices.py", "max_stars_repo_name": "SuccessionEcologicalServices/serenata-de-amor", "max_stars_repo_head_hexsha": "718a74e031ea0a4b020bf42801e1d23353e6bc34", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 59, "max_stars_repo_stars_event_min_datetime": "2018-10-03T18:46:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-05T22:39:17.000Z", "max_issues_repo_path": "research/develop/2016-12-01-irio-anomalies-in-meal-prices.py", "max_issues_repo_name": "SuccessionEcologicalServices/serenata-de-amor", "max_issues_repo_head_hexsha": "718a74e031ea0a4b020bf42801e1d23353e6bc34", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 16, "max_issues_repo_issues_event_min_datetime": "2018-10-03T21:36:50.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-12T22:10:16.000Z", "max_forks_repo_path": "research/develop/2016-12-01-irio-anomalies-in-meal-prices.py", "max_forks_repo_name": "SuccessionEcologicalServices/serenata-de-amor", "max_forks_repo_head_hexsha": "718a74e031ea0a4b020bf42801e1d23353e6bc34", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 20, "max_forks_repo_forks_event_min_datetime": "2018-10-03T19:14:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-12T20:50:44.000Z", "avg_line_length": 28.9614767255, "max_line_length": 546, "alphanum_fraction": 0.6881339023, "include": true, "reason": "import numpy,from scipy", "num_tokens": 4586, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46490157137338844, "lm_q2_score": 0.1259227631950178, "lm_q1q2_score": 0.05854169048104286}}
{"text": "r\"\"\"\nModule that creates and modifies parse trees of well formed boolean formulas.\n\nA parse tree of a boolean formula is a nested list, where each branch is either\na single variable, or a formula composed of either two variables and a binary\noperator or one variable and a unary operator. The function parse() produces\na parse tree that is simplified for the purposes of more efficient truth value\nevaluation. The function polish_parse() produces the full parse tree of a boolean\nformula which is used in functions related to proof and inference.  That is,\nparse() is meant to be used with functions in the logic module that perform\nsemantic operations on a boolean formula, and polish_parse() is to be used with\nfunctions that perform syntactic operations on a boolean formula.\n\nAUTHORS:\n\n- Chris Gorecki (2007): initial version\n\n- Paul Scurek (2013-08-01): added polish_parse, cleaned up python code,\n  updated docstring formatting\n\nEXAMPLES:\n\nFind the parse tree and variables of a string representation of a boolean formula::\n\n    sage: import sage.logic.logicparser as logicparser\n    sage: s = 'a|b&c'\n    sage: t = logicparser.parse(s)\n    sage: t\n    (['|', 'a', ['&', 'b', 'c']], ['a', 'b', 'c'])\n\nFind the full syntax parse tree of a string representation of a boolean formula::\n\n    sage: import sage.logic.logicparser as logicparser\n    sage: s = '(a&b)->~~c'\n    sage: logicparser.polish_parse(s)\n    ['->', ['&', 'a', 'b'], ['~', ['~', 'c']]]\n\nFind the tokens and distinct variables of a boolean formula::\n\n    sage: import sage.logic.logicparser as logicparser\n    sage: s = '~(a|~b)<->(c->c)'\n    sage: logicparser.tokenize(s)\n    (['(', '~', '(', 'a', '|', '~', 'b', ')', '<->', '(', 'c', '->', 'c', ')', ')'], ['a', 'b', 'c'])\n\nFind the parse tree of a boolean formula from a list of the formula's tokens::\n\n    sage: import sage.logic.logicparser as logicparser\n    sage: t = ['(', 'a', '->', '~', 'c', ')']\n    sage: logicparser.tree_parse(t)\n    ['->', 'a', ['~', 'c', None]]\n    sage: r = ['(', '~', '~', 'a', '|', 'b', ')']\n    sage: logicparser.tree_parse(r)\n    ['|', 'a', 'b']\n\nFind the full syntax parse tree of a boolean formula from a list of tokens::\n\n    sage: import sage.logic.logicparser as logicparser\n    sage: t = ['(', 'a', '->', '~', 'c', ')']\n    sage: logicparser.tree_parse(t, polish = True)\n    ['->', 'a', ['~', 'c']]\n    sage: r = ['(', '~', '~', 'a', '|', 'b', ')']\n    sage: logicparser.tree_parse(r, polish = True)\n    ['|', ['~', ['~', 'a']], 'b']\n\n\n\"\"\"\n#*****************************************************************************\n#       Copyright (C) 2007 Chris Gorecki <chris.k.gorecki@gmail.com>\n#       Copyright (C) 2013 Paul Scurek <scurek86@gmail.com>\n#\n#  Distributed under the terms of the GNU General Public License (GPL)\n#  as published by the Free Software Foundation; either version 2 of\n#  the License, or (at your option) any later version.\n#                  http://www.gnu.org/licenses/\n#*****************************************************************************\n\nfrom types import *\nimport string\n\n__symbols = '()&|~<->^'\n__op_list = ['~', '&', '|', '^', '->', '<->']\n\ndef parse(s):\n    r\"\"\"\n    Return a parse tree from a boolean formula s.\n\n    INPUT:\n\n    - ``s`` -- a string containing a boolean formula.\n\n    OUTPUT:\n\n    A list containing the prase tree and a list containing the\n    variables in a boolean formula in this order:\n\n    1. the list containing the pase tree\n    2. the list containing the variables\n\n    EXAMPLES:\n\n    This example illustrates how to produce the parse tree of a boolean formula s.\n\n    ::\n\n        sage: import sage.logic.logicparser as logicparser\n        sage: s = 'a|b&c'\n        sage: t = logicparser.parse(s)\n        sage: t\n        (['|', 'a', ['&', 'b', 'c']], ['a', 'b', 'c'])\n    \"\"\"\n    toks, vars_order = tokenize(s)\n    tree = tree_parse(toks)\n    # special case of tree == single variable\n    if isinstance(tree, StringType):\n        return ['&', tree, tree], vars_order\n    return tree, vars_order\n\ndef polish_parse(s):\n    r\"\"\"\n    Return the full syntax parse tree from a boolean formula s.\n\n    INPUT:\n\n    - ``s`` -- a string containing a boolean expression\n\n    OUTPUT:\n\n    The full syntax parse tree as a nested list\n\n    EXAMPLES:\n\n    This example illustrates how to find the full syntax parse tree of a boolean formula.\n\n    ::\n\n        sage: import sage.logic.logicparser as logicparser\n        sage: s = 'a|~~b'\n        sage: t = logicparser.polish_parse(s)\n        sage: t\n        ['|', 'a', ['~', ['~', 'b']]]\n\n    AUTHORS:\n\n    - Paul Scurek (2013-08-03)\n    \"\"\"\n    toks, vars_order = tokenize(s)\n    tree = tree_parse(toks, polish = True)\n    # special case where the formula s is a single variable\n    if isinstance(tree, StringType):\n        return vars_order\n    return tree\n\ndef tokenize(s):\n    r\"\"\"\n    Return the tokens and the distinct variables appearing in a boolean formula s.\n\n    INPUT:\n\n    - ``s`` -- a string representation of a boolean formula\n\n    OUTPUT:\n\n    The tokens and variables as an ordered pair of lists in the following order:\n\n    1. A list containing the tokens of s, in the order they appear in s\n    2. A list containing the distinct variables in s, in the order they appearn in s\n\n    EXAMPLES:\n\n    This example illustrates how to tokenize a string representation of a boolean formula.\n\n    ::\n\n        sage: import sage.logic.logicparser as logicparser\n        sage: s = 'a|b&c'\n        sage: t = logicparser.tokenize(s)\n        sage: t\n        (['(', 'a', '|', 'b', '&', 'c', ')'], ['a', 'b', 'c'])\n    \"\"\"\n    i = 0\n    toks = ['(']\n    vars_order = []\n\n    while i < len(s):\n        tok = \"\"\n        skip = valid = 1\n        if s[i] in '()~&|^':\n            tok = s[i]\n        elif s[i:i + 2] == '->':\n            tok = '->'\n            skip = 2\n        elif s[i:i + 3] == '<->':\n            tok = '<->'\n            skip = 3\n        # check to see if '-', '<' or '>' are used incorrectly\n        elif s[i] in '<->':\n            msg = \"'%s' can only be used as part of the operators '<->' or '->'.\" % (s[i])\n            raise SyntaxError, msg\n        if len(tok) > 0:\n            toks.append(tok)\n            i += skip\n            continue\n        else:\n            # token is a variable name\n            if s[i] == ' ':\n                i += 1\n                continue\n\n            while i < len(s) and s[i] not in __symbols and s[i] != ' ':\n                tok += s[i]\n                i += 1\n\n            if len(tok) > 0:\n                if tok[0] not in string.letters:\n                    valid = 0\n                for c in tok:\n                    if c not in string.letters and c not in string.digits and c != '_':\n                        valid = 0\n\n            if valid == 1:\n                toks.append(tok)\n                if tok not in vars_order:\n                    vars_order.append(tok)\n            else:\n                msg = 'invalid variable name ' + tok\n                msg += \": identifiers must begin with a letter and contain only \"\n                msg += \"alphanumerics and underscores\"\n                raise NameError, msg\n\n    toks.append(')')\n    return toks, vars_order\n\ndef tree_parse(toks, polish = False):\n    r\"\"\"\n    Return a parse tree from the tokens in toks.\n\n    INPUT:\n\n    - ``toks`` -- a list of tokens from a boolean formula\n\n    - ``polish`` -- (default: False) a boolean.  When true, tree_parse will return\n      the full syntax parse tree.\n\n    OUTPUT:\n\n    A parse tree in the form of a nested list that depends on ``polish`` as follows:\n\n    polish == False -- Return a simplified parse tree.\n\n    polish == True -- Return the full syntax parse tree.\n\n    EXAMPLES:\n\n    This example illustrates the use of tree_parse when polish == False.\n\n    ::\n\n        sage: import sage.logic.logicparser as logicparser\n        sage: t = ['(', 'a', '|', 'b', '&', 'c', ')']\n        sage: logicparser.tree_parse(t)\n        ['|', 'a', ['&', 'b', 'c']]\n\n    We now demonstrate the use of tree_parse when polish == True.\n\n    ::\n\n        sage: t = ['(', 'a', '->', '~', '~', 'b', ')']\n        sage: logicparser.tree_parse(t)\n        ['->', 'a', 'b']\n        sage: t = ['(', 'a', '->', '~', '~', 'b', ')']\n        sage: logicparser.tree_parse(t, polish = True)\n        ['->', 'a', ['~', ['~', 'b']]]\n    \"\"\"\n    stack = []\n    for tok in toks:\n        stack.append(tok)\n        if tok == ')':\n            lrtoks = []\n            while tok != '(':\n                tok = stack.pop()\n                lrtoks.insert(0, tok)\n            branch = parse_ltor(lrtoks[1:-1], polish = polish)\n            stack.append(branch)\n    return stack[0]\n\ndef parse_ltor(toks, n = 0, polish = False):\n    r\"\"\"\n    Return a parse tree from toks, where each token in toks is atomic.\n\n    INPUT:\n\n    - ``toks`` -- a list of tokens. Each token is atomic.\n\n    - ``n`` -- (default: 0) an integer representing which order of\n      operations are occurring\n\n    - ``polish`` -- (default: False) a boolean.  When true, double negations\n      are not cancelled and negated statements are turned into list of length two.\n\n    OUTPUT:\n\n    The parse tree as a nested list that depends on ``polish`` as follows:\n\n    polish == False - Return a simplified parse tree.\n\n    polish == True - Return the full syntax parse tree.\n\n    EXAMPLES:\n\n    This example illustrates the use of parse_ltor when polish == False.\n\n    ::\n\n        sage: import sage.logic.logicparser as logicparser\n        sage: t = ['a', '|', 'b', '&', 'c']\n        sage: logicparser.parse_ltor(t)\n        ['|', 'a', ['&', 'b', 'c']]\n\n    ::\n\n        sage: import sage.logic.logicparser as logicparser\n        sage: t = ['a', '->', '~', '~', 'b']\n        sage: logicparser.parse_ltor(t)\n        ['->', 'a', 'b']\n\n    We now repeat the previous example, but with polish == True.\n\n    ::\n\n        sage: import sage.logic.logicparser as logicparser\n        sage: t = ['a', '->', '~', '~', 'b']\n        sage: logicparser.parse_ltor(t, polish = True)\n        ['->', 'a', ['~', ['~', 'b']]]\n\n    \"\"\"\n    i = 0\n    for tok in toks:\n        if tok == __op_list[n]:\n            if tok == '~':\n                if not polish:\n                    # cancel double negations\n                    if toks[i] == '~' and toks[i + 1] == '~':\n                        del toks[i]\n                        del toks[i]\n                        return parse_ltor(toks, n)\n                    args = [toks[i], toks[i + 1], None]\n                    toks[i] = args\n                    del toks[i + 1]\n                    return parse_ltor(toks, n)\n                # This executes when creating the full syntax parse tree\n                else:\n                    j = i\n                    while toks[j] == '~':\n                        j += 1\n                    while j > i:\n                        args = [toks[j - 1], toks[j]]\n                        toks[j - 1] = args\n                        del toks[j]\n                        j -= 1\n                    return parse_ltor(toks, n = n, polish = polish)\n            else:\n                args = [toks[i - 1], toks[i], toks[i + 1]]\n                toks[i - 1] = [args[1], args[0], args[2]]\n                del toks[i]\n                del toks[i]\n                return parse_ltor(toks, n)\n        i += 1\n    if n + 1 < len(__op_list):\n        return parse_ltor(toks, n + 1)\n    if len(toks) > 1:\n        raise SyntaxError\n    return toks[0]\n\ndef apply_func(tree, func):\n    r\"\"\"\n    Apply func to each node of tree.  Return a new parse tree.\n\n    INPUT:\n\n    - ``tree`` -- a parse tree of a boolean formula\n\n    - ``func`` -- a function to be applied to each node of tree.  This may\n      be a function that comes from elsewhere in the logic module.\n\n    OUTPUT:\n\n    The new parse tree in the form of a nested list\n\n    EXAMPLES:\n\n    This example uses :func:`apply_func` where ``func`` switches two entries of tree.\n\n    ::\n\n        sage: import sage.logic.logicparser as logicparser\n        sage: t = ['|', ['&', 'a', 'b'], ['&', 'a', 'c']]\n        sage: f = lambda t: [t[0], t[2], t[1]]\n        sage: logicparser.apply_func(t, f)\n        ['|', ['&', 'c', 'a'], ['&', 'b', 'a']]\n    \"\"\"\n    if type(tree[1]) is ListType and type(tree[2]) is ListType:\n        lval = apply_func(tree[1], func)\n        rval = apply_func(tree[2], func)\n    elif type(tree[1]) is ListType:\n        lval = apply_func(tree[1], func)\n        rval = tree[2]\n    elif type(tree[2]) is ListType:\n        lval = tree[1]\n        rval = apply_func(tree[2], func)\n    else:\n        lval = tree[1]\n        rval = tree[2]\n    return func([tree[0], lval, rval])\n\n\n", "meta": {"hexsha": "649979827afda8f04419924e223e662a036b83bf", "size": 12598, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/logic/logicparser.py", "max_stars_repo_name": "bopopescu/sage-5", "max_stars_repo_head_hexsha": "9d85b34956ca2edd55af307f99c5d3859acd30bf", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2015-01-04T07:15:06.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T15:15:18.000Z", "max_issues_repo_path": "src/sage/logic/logicparser.py", "max_issues_repo_name": "bopopescu/sage-5", "max_issues_repo_head_hexsha": "9d85b34956ca2edd55af307f99c5d3859acd30bf", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/logic/logicparser.py", "max_forks_repo_name": "bopopescu/sage-5", "max_forks_repo_head_hexsha": "9d85b34956ca2edd55af307f99c5d3859acd30bf", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2016-09-28T13:12:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-12T09:28:34.000Z", "avg_line_length": 30.2836538462, "max_line_length": 101, "alphanum_fraction": 0.5246864582, "include": true, "reason": "import sage", "num_tokens": 3308, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48438008427698437, "lm_q2_score": 0.12085322140796939, "lm_q1q2_score": 0.058538893570737265}}
{"text": "# -*- coding: utf-8 -*-\r\n\"\"\"\r\nAssignment Chaper 01 (Think Stats 2, Allen B. Downey)\r\nEx 1-2\r\nSelf-study on statistics using pyhton\r\n@author: Github: @rafaelmm82\r\n\"\"\"\r\n\r\nfrom __future__ import print_function, division\r\n\r\nimport sys\r\nimport numpy as np\r\nimport thinkstats2\r\n\r\nfrom collections import defaultdict\r\n\r\n\r\ndef ReadFemResp(dct_file='2002FemResp.dct',\r\n                dat_file='2002FemResp.dat.gz',\r\n                nrows=None):\r\n    \"\"\"Reads the NSFG respondent data.\r\n\r\n    dct_file: string file name\r\n    dat_file: string file name\r\n\r\n    returns: DataFrame\r\n    \"\"\"\r\n    dct = thinkstats2.ReadStataDct(dct_file)\r\n    df = dct.ReadFixedWidth(dat_file, compression='gzip', nrows=nrows)\r\n    CleanFemResp(df)\r\n    return df\r\n\r\n\r\ndef CleanFemResp(df):\r\n    \"\"\"Recodes variables from the respondent frame.\r\n\r\n    df: DataFrame\r\n    \"\"\"\r\n    pass\r\n\r\n\r\ndef ReadFemPreg(dct_file='2002FemPreg.dct',\r\n                dat_file='2002FemPreg.dat.gz'):\r\n    \"\"\"Reads the NSFG pregnancy data.\r\n\r\n    dct_file: string file name\r\n    dat_file: string file name\r\n\r\n    returns: DataFrame\r\n    \"\"\"\r\n    dct = thinkstats2.ReadStataDct(dct_file)\r\n    df = dct.ReadFixedWidth(dat_file, compression='gzip')\r\n    CleanFemPreg(df)\r\n    return df\r\n\r\n\r\ndef CleanFemPreg(df):\r\n    \"\"\"Recodes variables from the pregnancy frame.\r\n\r\n    df: DataFrame\r\n    \"\"\"\r\n    # mother's age is encoded in centiyears; convert to years\r\n    df.agepreg /= 100.0\r\n\r\n    # birthwgt_lb contains at least one bogus value (51 lbs)\r\n    # replace with NaN\r\n    df.loc[df.birthwgt_lb > 20, 'birthwgt_lb'] = np.nan\r\n    \r\n    # replace 'not ascertained', 'refused', 'don't know' with NaN\r\n    na_vals = [97, 98, 99]\r\n    df.birthwgt_lb.replace(na_vals, np.nan, inplace=True)\r\n    df.birthwgt_oz.replace(na_vals, np.nan, inplace=True)\r\n    df.hpagelb.replace(na_vals, np.nan, inplace=True)\r\n\r\n    df.babysex.replace([7, 9], np.nan, inplace=True)\r\n    df.nbrnaliv.replace([9], np.nan, inplace=True)\r\n\r\n    # birthweight is stored in two columns, lbs and oz.\r\n    # convert to a single column in lb\r\n    # NOTE: creating a new column requires dictionary syntax,\r\n    # not attribute assignment (like df.totalwgt_lb)\r\n    df['totalwgt_lb'] = df.birthwgt_lb + df.birthwgt_oz / 16.0    \r\n\r\n    # due to a bug in ReadStataDct, the last variable gets clipped;\r\n    # so for now set it to NaN\r\n    df.cmintvw = np.nan\r\n\r\n\r\ndef ValidatePregnum(resp, preg):\r\n    \"\"\"Validate pregnum in the respondent file.\r\n\r\n    resp: respondent DataFrame\r\n    preg: pregnancy DataFrame\r\n    \"\"\"\r\n    # make the map from caseid to list of pregnancy indices\r\n    preg_map = MakePregMap(preg)\r\n    \r\n    # iterate through the respondent pregnum series\r\n    for index, pregnum in resp.pregnum.iteritems():\r\n        caseid = resp.caseid[index]\r\n        indices = preg_map[caseid]\r\n\r\n        # check that pregnum from the respondent file equals\r\n        # the number of records in the pregnancy file\r\n        if len(indices) != pregnum:\r\n            print(caseid, len(indices), pregnum)\r\n            return False\r\n\r\n    return True\r\n\r\n\r\ndef MakePregMap(df):\r\n    \"\"\"Make a map from caseid to list of preg indices.\r\n\r\n    df: DataFrame\r\n\r\n    returns: dict that maps from caseid to list of indices into `preg`\r\n    \"\"\"\r\n    d = defaultdict(list)\r\n    for index, caseid in df.caseid.iteritems():\r\n        d[caseid].append(index)\r\n    return d\r\n\r\n\r\ndef main():\r\n    \"\"\"Tests the functions in this module.\r\n\r\n    script: string script name\r\n    \"\"\"\r\n    # read and validate the respondent file\r\n    resp = ReadFemResp()\r\n\r\n    assert(len(resp) == 7643)\r\n    assert(resp.pregnum.value_counts()[1] == 1267)\r\n\r\n    # read and validate the pregnancy file\r\n    preg = ReadFemPreg()\r\n    print(preg.shape)\r\n    \r\n\r\n    # validate that the pregnum column in `resp` matches the number\r\n    # of entries in `preg`\r\n    assert(ValidatePregnum(resp, preg))\r\n\r\n    \r\n    print('Everything is ok!')\r\n\r\n\r\nif __name__ == '__main__':\r\n    main()\r\n", "meta": {"hexsha": "ab258d42b1749cfeb357ac1cab037c2d01d8a639", "size": 3956, "ext": "py", "lang": "Python", "max_stars_repo_path": "ThinkStats2/rafael_chap01ex.py", "max_stars_repo_name": "rafaelmm82/learning", "max_stars_repo_head_hexsha": "c8cd7408404dbbcc0af3ae0a18c6c311d4003269", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ThinkStats2/rafael_chap01ex.py", "max_issues_repo_name": "rafaelmm82/learning", "max_issues_repo_head_hexsha": "c8cd7408404dbbcc0af3ae0a18c6c311d4003269", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ThinkStats2/rafael_chap01ex.py", "max_forks_repo_name": "rafaelmm82/learning", "max_forks_repo_head_hexsha": "c8cd7408404dbbcc0af3ae0a18c6c311d4003269", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.1986754967, "max_line_length": 71, "alphanum_fraction": 0.6365015167, "include": true, "reason": "import numpy", "num_tokens": 1023, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.11757212117767352, "lm_q1q2_score": 0.05832680383405105}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Advanced Binary Image Segmentation for the Geo- and Eco-sciences, using Deep Learning\n# \n# ## Case Study: Detecting Intertidal Reefs\n# \n# #### Daniel Buscombe, MARDA Science\n# \n# ![](https://mardascience.com/wp-content/uploads/2019/06/cropped-MardaScience_logo-5.png)\n\n# Before you do anything, go to `File > Save copy in Drive` so you can keep and work on your own copy\n# \n# ## Part 5: Train a oyster reef masker using a custom learning rate scheduler\n# \n# This jupyter notebook running on Google Colab is part of the \"Advanced Binary Image Segmentation for the Geo- and Eco-sciences, using Deep Learning\" course. The main course website can be accessed [here](https://mardascience.gitlab.io/binary_image_segmentation_for_geosciences/#/)\n# \n# Then we will construct, train and evaluate the model. In the [oysterNet paper](https://zslpublications.onlinelibrary.wiley.com/doi/full/10.1002/rse2.134), the authors used a bigger, more sophisticated model for `instance segmentation`, that is, semantic segmentation that is aware of all the different `instances` of the class (i.e. each individual piece of reef). The model they use is called `Mask RCNN`, the implementation of which is [here](https://github.com/matterport/Mask_RCNN). That is a large and very complicated model that is hard to experiment with. The research behind the [oysterNet paper](https://zslpublications.onlinelibrary.wiley.com/doi/full/10.1002/rse2.134) is state-of-the-art.\n# \n# Here, we use a simpler model with fewer parameters (namely, a residual UNet) and acheive acceptable results for a semantic segmentation (predicting the masks of where the reefs are, rather than by individual instances). The UNet is the same we used in a [previous set of tutorials](https://mardascience.gitlab.io/deep_learning_landscape_classification/#/) and is relatively simple to adapt and play with to demonstrate a few principles.\n# \n# **In this tutorial, we'll adapt our training strategies in search of a more satisfactory result. This may or may not be directly transferable with the same fidelity to your own dataset, but this is a good trick to learn and understand that might help for your data modelling purposes. This time we use a cyclical learning rate scheduler**\n# \n# According to [this](https://arxiv.org/abs/1506.01186) and [this](https://www.pyimagesearch.com/2019/07/29/cyclical-learning-rates-with-keras-and-deep-learning/), there are a few reasons why we would want to trial this strategy\n# * a low learning rate may not be sufficient to break out of the non-optimal areas of the loss landscape and descend into areas of the loss landscape with lower loss.\n# * our model and optimizer may be very sensitive to our initial learning rate choice\n# \n# \n# This is designed to demonstrate a problem-solving strategy, and also a principle that often applies to natural imagery:\n# \n# > It's not just the model you choose, it's how you train it that counts\n# \n# \n# \n\n# ### Import libraries\n\n# In[ ]:\n\n\nimport os #for accessing operating system utilities\nfrom glob import glob #for finding files that match a certain string pattern\nimport matplotlib.pyplot as plt #for plotting\nimport numpy as np #for numerical operations\nimport random, string #for creating random strings\nimport tensorflow as tf #tensorflow\nimport json # for reading lable annotations in json format\nimport requests #for downloading files \nfrom PIL import Image, ImageFilter #for reading and filtering imagery\nimport skimage.draw #for making masks (raster label images) from label annotations\nfrom skimage.transform import resize #for resizing imagery\nfrom psutil import virtual_memory #for interrogating our filesystem and RAM specifications\nfrom imageio import imwrite\n\n\n# In[ ]:\n\n\nfrom tensorflow.keras.callbacks import ReduceLROnPlateau, EarlyStopping, ModelCheckpoint\nfrom random import shuffle\nfrom tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, UpSampling2D, BatchNormalization\nfrom tensorflow.keras.layers import Concatenate, Conv2DTranspose, Flatten, Activation, Add\nfrom tensorflow.keras.models import Model\n\n\n# ### Prepare the data\n\n# #### Download the  imagery\n# \n\n# For the remainder of the tutorials, we'll be using this version of the data, consisting of imagery and image labels, with an augmented training set consisting of double the original number of imagery, half of which have been augmented with random flips, zoms and rotations\n\n# In[ ]:\n\n\n# from https://stackoverflow.com/questions/38511444/python-download-files-from-google-drive-using-url\n\ndef download_file_from_google_drive(id, destination):\n    URL = \"https://docs.google.com/uc?export=download\"\n\n    session = requests.Session()\n\n    response = session.get(URL, params = { 'id' : id }, stream = True)\n    token = get_confirm_token(response)\n\n    if token:\n        params = { 'id' : id, 'confirm' : token }\n        response = session.get(URL, params = params, stream = True)\n\n    save_response_content(response, destination)    \n\ndef get_confirm_token(response):\n    for key, value in response.cookies.items():\n        if key.startswith('download_warning'):\n            return value\n\n    return None\n\ndef save_response_content(response, destination):\n    \"\"\"\n    response = filename for input\n    destination = filename for output\n    \"\"\"    \n    CHUNK_SIZE = 32768\n\n    with open(destination, \"wb\") as f:\n        for chunk in response.iter_content(CHUNK_SIZE):\n            if chunk: # filter out keep-alive new chunks\n                f.write(chunk)\n\n\n# In[ ]:\n\n\nfile_id = '19RgkzaD9w-rvAF9uBpqMONnwF0lJVPh3'\ndestination = 'train_images.tar.gz'\ndownload_file_from_google_drive(file_id, destination)\n\n\n# In[ ]:\n\n\nget_ipython().system('tar -xf train_images.tar.gz > tmp.txt')\n\n\n# In[ ]:\n\n\nfile_id = '1gjWGXO7mtBhJuSOqrG6B1inzLF8TfTSX'\ndestination = 'val_images.tar.gz'\ndownload_file_from_google_drive(file_id, destination)\n\n\n# In[ ]:\n\n\nget_ipython().system('tar -xf val_images.tar.gz > tmp.txt')\n\n\n# In[ ]:\n\n\nfile_id = '1x8HrgEStkBCdBmFNo1xa0x6LCVE2GE1g'\ndestination = 'train_labels.tar.gz'\ndownload_file_from_google_drive(file_id, destination)\n\n\n# In[ ]:\n\n\nget_ipython().system('tar -xf train_labels.tar.gz > tmp.txt')\n\n\n# In[ ]:\n\n\nfile_id = '1v0kPgwZVQNrGAk0awJi31W83CYvHJbeX'\ndestination = 'val_labels.tar.gz'\ndownload_file_from_google_drive(file_id, destination)\n\n\n# In[ ]:\n\n\nget_ipython().system('tar -xf val_labels.tar.gz > tmp.txt')\n\n\n# In[ ]:\n\n\nroot = './content/'\n\n\n# Check to see how many images we now have to work with\n\n# In[ ]:\n\n\ntrain_files = glob(root+\"1kx1k_dataset/train_images/data/*.png\")\nval_files = glob(root+\"1kx1k_dataset/val_images/data/*.png\")\n\nprint(\"# train files: %i\" % (len(train_files)))\nprint(\"# validation files: %i\" % (len(val_files)))\n\n\n# ### Setting up model training\n\n# #### Custom batch generator\n\n# We are going to feed images to the network in batches. The batch size (number of images and associated labels) will be ...\n\n# In[ ]:\n\n\nbatch_size = 6\n\n\n# The next function is an image batch generator. A `generator` is a special type of python function that `yields` a set of data. In our case, it will yield a set of `batch_size` images and labels drawn randomly from the entire set of `files` provided\n# \n# It opens the file, reads it into a numpy array with correct dimensions checked, and then does the same for the label image. It scales the image by dividing by 255, do turn the 8-bit data scaled between 0 and 255 to data scaled between 0 and 1. The labels are flattened from 3D (RGB) to 2D (greyscale integers)\n\n# In[ ]:\n\n\ndef image_batch_generator(files, sz, batch_size = 4):\n\n  while True: # this is here because it will be called repeatedly by the training function\n\n    #extract a random subset of files of length \"batch_size\"\n    batch = np.random.choice(files, size = batch_size)\n\n    #variables for collecting batches of inputs (x) and outputs (y)\n    batch_x = []\n    batch_y = []\n\n    #cycle through each image in the batch\n    for f in batch:\n\n        #preprocess the raw images\n        raw = Image.open(f)\n        raw = raw.resize(sz)\n        raw = raw.filter(ImageFilter.UnsharpMask(radius=20, percent=100))\n        raw = np.array(raw)\n\n        #check the number of channels because some of the images are RGBA or GRAY\n        if len(raw.shape) == 2:\n            raw = np.stack((raw,)*3, axis=-1)\n\n        else:\n            raw = raw[:,:,0:3]\n\n        #get the image dimensions, find the min dimension, then square the image off\n        nx, ny, nz = np.shape(raw)\n        n = np.minimum(nx,ny)\n        raw = raw[:n,:n,:]\n\n        raw[np.isnan(raw)] = 1e-5\n        raw[np.isinf(raw)] = 1e-5\n\n        batch_x.append(raw)\n\n        #get the masks.\n        maskfile = f.replace('_images','_labels').replace('.png','.jpg')\n        mask = Image.open(maskfile)\n        # the mask is 3-dimensional so get the max in each channel to flatten to 2D\n        try:\n           mask = np.max(np.array(mask.resize(sz)),axis=2)\n        except:\n           mask = np.array(mask.resize(sz))\n\n        # water pixels are always greater than 170\n        mask = (mask>170).astype('int') ##170 = (2/3)*255\n\n        mask = mask[:n,:n]\n\n        mask[np.isnan(mask)] = 1e-5\n        mask[np.isinf(mask)] = 1e-5\n        batch_y.append(mask)\n\n    #preprocess a batch of images and masks\n    batch_x = np.array(batch_x) #/255. #divide image by 255 to normalize\n    batch_y = np.array(batch_y)\n    batch_y = np.expand_dims(batch_y,1) #add singleton dimension to batch_y\n\n    yield (batch_x, batch_y) #yield both the image and the label together\n\n\n# We will specify input imagery of size `(512, 512, 3)`\n\n# In[ ]:\n\n\nsz = (512, 512)\n\n\n# #### Build the model\n\n# \n\n# In[ ]:\n\n\ndef batchnorm_act(x):\n    x = BatchNormalization()(x)\n    return Activation(\"relu\")(x)\n\ndef conv_block(x, filters, kernel_size=(3, 3), padding=\"same\", strides=1):\n    conv = batchnorm_act(x)\n    return Conv2D(filters, kernel_size, padding=padding, strides=strides)(conv)\n\ndef bottleneck_block(x, filters, kernel_size=(3, 3), padding=\"same\", strides=1):\n    conv = Conv2D(filters, kernel_size, padding=padding, strides=strides)(x)\n    conv = conv_block(conv, filters, kernel_size=kernel_size, padding=padding, strides=strides)\n    \n    bottleneck = Conv2D(filters, kernel_size=(1, 1), padding=padding, strides=strides)(x)\n    bottleneck = batchnorm_act(bottleneck)\n    \n    return Add()([conv, bottleneck])\n\ndef res_block(x, filters, kernel_size=(3, 3), padding=\"same\", strides=1):\n    res = conv_block(x, filters, kernel_size=kernel_size, padding=padding, strides=strides)\n    res = conv_block(res, filters, kernel_size=kernel_size, padding=padding, strides=1)\n    \n    bottleneck = Conv2D(filters, kernel_size=(1, 1), padding=padding, strides=strides)(x)\n    bottleneck = batchnorm_act(bottleneck)\n    \n    return Add()([bottleneck, res])\n\ndef upsamp_concat_block(x, xskip):\n    u = UpSampling2D((2, 2))(x)\n    return Concatenate()([u, xskip])\n\ndef res_unet(sz, f):\n    inputs = Input(sz)\n    \n    ## downsample  \n    e1 = bottleneck_block(inputs, f); f = int(f*2)\n    e2 = res_block(e1, f, strides=2); f = int(f*2)\n    e3 = res_block(e2, f, strides=2); f = int(f*2)\n    e4 = res_block(e3, f, strides=2); f = int(f*2)\n    _ = res_block(e4, f, strides=2)\n    \n    ## bottleneck\n    b0 = conv_block(_, f, strides=1)\n    _ = conv_block(b0, f, strides=1)\n    \n    ## upsample\n    _ = upsamp_concat_block(_, e4)\n    _ = res_block(_, f); f = int(f/2)\n    \n    _ = upsamp_concat_block(_, e3)\n    _ = res_block(_, f); f = int(f/2)\n    \n    _ = upsamp_concat_block(_, e2)\n    _ = res_block(_, f); f = int(f/2)\n    \n    _ = upsamp_concat_block(_, e1)\n    _ = res_block(_, f)\n    \n    ## classify\n    outputs = Conv2D(1, (1, 1), padding=\"same\", activation=\"sigmoid\")(_)\n    \n    #model creation \n    model = Model(inputs=[inputs], outputs=[outputs])\n    return model\n\t\n\n\n# This is a class imbalanced problem, with many more `non-reef` pixels compared to `reef` pixels (the target class)\n# \n# So, we will use (Sorensen-)Dice loss instead of the more common IoU score (Jaccard Index) which is more suitable for class balanced problems\n\n# In[ ]:\n\n\nsmooth = 1.\n\ndef dice_coef(y_true, y_pred):\n    y_true_f = tf.reshape(tf.dtypes.cast(y_true, tf.float32), [-1])\n    y_pred_f = tf.reshape(tf.dtypes.cast(y_pred, tf.float32), [-1])\n    intersection = tf.reduce_sum(y_true_f * y_pred_f)\n    return (2. * intersection + smooth) / (tf.reduce_sum(y_true_f) + tf.reduce_sum(y_pred_f) + smooth)\n\ndef dice_coef_loss(y_true, y_pred):\n    return 1.0 - dice_coef(y_true, y_pred)\n\n\n# Next, we make and compile our model\n# \n# As we saw in lesson 1, model compilation is a necessary step, involving specifiying the 'optimizer' (we will use `rmsprop` but `adam` is also a good one to use, in my experience). The loss function is the Dice loss, and the metric we want to keep track of in the dice coefficient\n\n# In[ ]:\n\n\nmodel = res_unet(sz+(3,), batch_size)\nmodel.compile(optimizer = 'adam', loss = dice_coef_loss, metrics = [dice_coef])\n\n\n# Let's take a look at how many parameters we have to optimize\n\n# In[ ]:\n\n\nmodel.summary()\n\n\n# We have over 600,000 trainable parameters. This is a lot, for any model, but tiny compared to the number of parameters in some deep learning models, with up to hundreds of millions of trainable parameters\n\n# ### Train the model with a custom \"learning rate scheduler\"\n\n# In[ ]:\n\n\ncallbacks = tf.keras.callbacks\nbackend = tf.keras.backend\n\n\nclass PlotLearning(callbacks.Callback):\n\n    def on_train_begin(self, logs={}):\n        self.i = 0\n        self.x = []\n        self.losses = []\n        self.val_losses = []\n        self.acc = []\n        self.val_acc = []\n        #self.fig = plt.figure()\n        self.logs = []\n    def on_epoch_end(self, epoch, logs={}):\n        self.logs.append(logs)\n        self.x.append(self.i)\n        self.losses.append(logs.get('loss'))\n        self.val_losses.append(logs.get('val_loss'))\n        self.acc.append(logs.get('dice_coef'))\n        self.val_acc.append(logs.get('val_dice_coef'))\n        self.i += 1\n        print('i=',self.i,'loss=',logs.get('loss'),'val_loss=',logs.get('val_loss'),'dice_coef=',logs.get('dice_coef'),'val_dice_coef=',logs.get('val_dice_coef'))\n\n        #choose a random test image and preprocess\n        f = np.random.choice(val_files)\n\n        raw = np.array(Image.open(f).resize(sz))\n\n        #predict the mask\n        pred = 255*model.predict(np.expand_dims(raw, 0)).squeeze()\n        print(np.max(pred))\n\n        #mask post-processing\n        msk  = (pred>170).astype('int') \n\n        msk = np.stack((msk,)*3, axis=-1)\n\n        #show the mask and the segmented image\n        combined = np.concatenate([raw, msk, raw* msk], axis = 1)\n        plt.axis('off')\n        plt.imshow(combined)\n        plt.show()\n        #plt.savefig(str(self.i)+'.png', dpi=100, bbox_inches='tight')\n\n\n# In Part 3 we used callback functions that adaptively change the pace of training (using an adaptive learning rate), called [\"reduce loss on plateau\"](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/ReduceLROnPlateau)\n# \n# This time we'll control precisely the learning rate scheduler to invoke a function that describes the learning rate as a function of training epoch\n# \n# To do so requires a new class that will feed the model the correct learning rate based on the epoch it is current training on\n# \n# \n\n# In[ ]:\n\n\nclass LearningRateScheduler(callbacks.Callback):\n    def __init__(self,\n                 schedule,\n                 learning_rate=None,\n                 steps_per_epoch=None,\n                 verbose=0):\n        super(LearningRateScheduler, self).__init__()\n        self.learning_rate = learning_rate\n        self.schedule = schedule\n        self.verbose = verbose\n        self.warmup_epochs = 0 \n        self.warmup_steps = 0 \n        self.global_batch = 0\n\n    def on_train_batch_begin(self, batch, logs=None):\n        self.global_batch += 1\n        if self.global_batch < self.warmup_steps:\n            if not hasattr(self.model.optimizer, 'lr'):\n                raise ValueError('Optimizer must have a \"lr\" attribute.')\n            lr = self.learning_rate * self.global_batch / self.warmup_steps\n            backend.set_value(self.model.optimizer.lr, lr)\n            if self.verbose > 0:\n                print('\\nBatch %05d: LearningRateScheduler warming up learning '\n                      'rate to %s.' % (self.global_batch, lr))\n\n    def on_epoch_begin(self, epoch, logs=None):\n        if not hasattr(self.model.optimizer, 'lr'):\n            raise ValueError('Optimizer must have a \"lr\" attribute.')\n        lr = float(backend.get_value(self.model.optimizer.lr))\n\n        if epoch >= self.warmup_epochs:\n            try:  # new API\n                lr = self.schedule(epoch - self.warmup_epochs, lr)\n            except TypeError:  # old API\n                lr = self.schedule(epoch - self.warmup_epochs)\n            if not isinstance(lr, (float, np.float32, np.float64)):\n                raise ValueError('The output of the \"schedule\" function '\n                                 'should be float.')\n            backend.set_value(self.model.optimizer.lr, lr)\n\n            if self.verbose > 0:\n                print('\\nEpoch %05d: LearningRateScheduler reducing learning '\n                      'rate to %s.' % (epoch + 1, lr))\n\n    def on_epoch_end(self, epoch, logs=None):\n        logs = logs or {}\n        logs['lr'] = backend.get_value(self.model.optimizer.lr)\n\n\n# In[ ]:\n\n\n\n\n\n# This is our cosine function implementation for a 'cyclical' learning rate between two specified bounds, `min_lr` (minimum learning rate) and `max_lr` (maximum learning rate)\n\n# In[ ]:\n\n\ndef cosine_ratedecay(max_epochs, max_lr, min_lr=1e-6): \n    \"\"\"\n    cosine scheduler.\n    :param max_epochs: max epochs\n    :param max_lr: max lr\n    :param min_lr: min lr\n    :return: current lr\n    \"\"\"\n    max_epochs = max_epochs ##- 5 if warmup else max_epochs\n\n    def ratedecay(epoch):\n        lrate = min_lr + (max_lr - min_lr) * (\n                1 + np.cos(np.pi*2 * epoch / max_epochs)) / 2\n\n        return lrate\n\n    return ratedecay\n\n\n# We now have two new hyperparameters we didn't have before\n\n# In[ ]:\n\n\n# maximum learning rate (lambda)\nmax_lr = 1e-4\n\nmax_epochs = 200\n\n\n# The \"two bites at the cherry\" learning rate scheduler. The intuition behind this is that the model searches progressively finer portions of the loss parameter space, up until about epoch 70, then the function increases again, using larger learning rates to explore other 'valleys' in the loss landscape. \n# \n# I informally call it the 'two bites at the cherry' function because it facilitates the following situation: the optimal low in the loss landscape was not effectively found by the first loop of progressively lower learning rates. Giving the model a 'second bite' allows it to find a new low by adjusting learning rates to be coarse, so it can hop to different areas of the loss landscape more effectively \n\n# In[ ]:\n\n\nmin_lr = 1e-6\ndef ratedecay(epoch):\n    lrate = min_lr + (max_lr - min_lr) * (\n            1 + np.cos(np.pi*3 * epoch / max_epochs)) / 2\n\n    return lrate\n\nplt.plot(ratedecay(np.arange(max_epochs)))    \n\n\n# Now we have defined all these hyperparameters (parameters that we chose, not automatically determined by the model), we can make a function that builds all the various callbacks together into a list, which can then be passed to the model training (`.fit()` function)\n\n# In[ ]:\n\n\ndef build_callbacks(filepath, lr_ratedecay, lr, steps_per_epoch):\n\n    # set checkpoint file\n    model_checkpoint = ModelCheckpoint(filepath, monitor='val_loss',\n                                   verbose=0, save_best_only=True, mode='min',\n                                   save_weights_only = True)\n\n    # learning rate scheduler setting\n    learning_rate_scheduler = LearningRateScheduler(lr_ratedecay, lr, steps_per_epoch,\n                                                verbose=1)\n\n    callbacks = [model_checkpoint, learning_rate_scheduler, PlotLearning()]\n\n    return callbacks\n\n\n# Next, set up a name for the `.h5` file that will be used to store model weights.\n# \n# Finally, we train the model by calling the `.fit()` command and providing all the generators and hyperparameters defined in the callbacks\n# \n# The number of training and validation steps is simply the number of respective files divided by the batch size\n\n# In[ ]:\n\n\nfilepath = 'reefs_weights_uresnet'+str(batch_size)+'_'+str(max_epochs)+'epochs_cosine_lrscheduler.h5'\n\ntrain_generator = image_batch_generator(train_files, sz, batch_size = batch_size)\nval_generator  = image_batch_generator(val_files, sz, batch_size = batch_size)\ntrain_steps = len(train_files) //batch_size\nval_steps = len(val_files) //batch_size\nsteps_per_epoch = len(train_files) // batch_size\n\nprint(train_steps)\nprint(val_steps)\nprint(steps_per_epoch)\n\nlr_ratedecay = cosine_ratedecay(max_epochs,max_lr)\n\n\n# If you'd rather not wait the 3-6 hours it might take to train the model you should leave the following cell uncommented \n\n# In[ ]:\n\n\nfile_id = '1LyjyOxuzYzmWrwh6kxPVDZZWEzZGehNq'\ndestination = 'weights_part5.h5'\ndownload_file_from_google_drive(file_id, destination)\nmodel.load_weights(destination)\nmax_epochs = 5 #just use 5 epochs\n\n\n# If you wish to train the model your own model, uncomment the cells below\n\n# In[ ]:\n\n\n# hist = model.fit(train_generator,\n#                 epochs = max_epochs, steps_per_epoch = train_steps,\n#                 validation_data = val_generator, validation_steps = val_steps,\n#                 callbacks = build_callbacks(filepath,lr_ratedecay, max_lr, steps_per_epoch))\n\n\n# #### Plot the training history\n\n# In the above, we gave an output variable to the `.fit()` command. This contains the training histories. That is, losses and metrics as a function of epoch. You can access the variables in the dictionary like so\n\n# In[ ]:\n\n\n# hist.history.keys()\n\n\n# Let's make a plot of the histories of both train and validation losses and dice coefficients, and also the history of the learning rate\n\n# In[ ]:\n\n\n# plt.figure(figsize=(20,10))\n# plt.subplot(131)\n# plt.plot(hist.history['dice_coef'], 'b', label='train Dice coefficient')\n# plt.plot(hist.history['val_dice_coef'], 'k', label='validation Dice coefficient')\n# plt.xlabel('Epoch number'); plt.ylabel('Dice coefficent')\n# plt.legend()\n\n# plt.subplot(132)\n# plt.plot(hist.history['loss'], 'b', label='train loss')\n# plt.plot(hist.history['val_loss'], 'k', label='validation loss')\n# plt.xlabel('Epoch number'); plt.ylabel('Loss')\n# plt.legend()\n\n# plt.subplot(133)\n# plt.plot(hist.history['lr'], 'g')\n# plt.xlabel('Epoch number'); plt.ylabel('Learning rate')\n\n\n# ### Test the model\n\n# Get the test set of files and untar like we did the other sets\n\n# In[ ]:\n\n\nfile_id = '1lL6cbUNhwAQsDl4P4LIYiOMOwKxrhq-c'\ndestination = 'test_images.tar.gz'\ndownload_file_from_google_drive(file_id, destination)\n\n\n# In[ ]:\n\n\nget_ipython().system('tar -xf test_images.tar.gz > tmp.txt')\n\n\n# In[ ]:\n\n\nfile_id = '1GVZgjzuVatp-OjU5s5DJOgAteUvN1yDC'\ndestination = 'test_labels.tar.gz'\ndownload_file_from_google_drive(file_id, destination)\n\n\n# In[ ]:\n\n\nget_ipython().system('tar -xf test_labels.tar.gz > tmp.txt')\n\n\n# Get a test generator\n\n# In[ ]:\n\n\ntest_files = glob(root+\"1kx1k_dataset/test_images/*.png\")\n\ntest_generator = image_batch_generator(test_files, sz, batch_size = batch_size)\n\nprint(\"# test files: %i\" % (len(test_files)))\n\n\n# Use the `.evaluate()` function of the model to get average Dice scores and losses for the test set\n# \n# \n\n# In[ ]:\n\n\n# some other training parameters\nsteps = len(test_files) // batch_size\n\n# testing\nscores = model.evaluate(test_generator, steps=steps) \n\nprint('loss={loss:0.4f}, Mean Dice={dice_coef:0.4f}'.format(loss=scores[0], dice_coef=scores[1]))\n\n\n# In the [oysterNet paper](https://zslpublications.onlinelibrary.wiley.com/doi/full/10.1002/rse2.134), the authors reeport a best precision of 0.771 and recall of 0.772. The Dice score is mathematically equivalent to the F1 score, the harmonic mean of precision and recall, or 77%\n# \n# In Part 4, we acheived an average dice score of ~72% using a Dice loss function and adaptive learning rates that were contingent on validation loss\n# \n# This time, with a cyclical learning rate, we acheive ~80% - approximately the same as the original paper (actually, a little higher!)\n", "meta": {"hexsha": "acad3eeb7271c88c9eafe3caae21ea88bcdccfa0", "size": 24300, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/Oyster_reefs/Part5_Training_Model3.py", "max_stars_repo_name": "MARDAScience/UNets4IntertidalReefs", "max_stars_repo_head_hexsha": "551c22e29bafe6b01686a833aa881be2b52b6a2a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "scripts/Oyster_reefs/Part5_Training_Model3.py", "max_issues_repo_name": "MARDAScience/UNets4IntertidalReefs", "max_issues_repo_head_hexsha": "551c22e29bafe6b01686a833aa881be2b52b6a2a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scripts/Oyster_reefs/Part5_Training_Model3.py", "max_forks_repo_name": "MARDAScience/UNets4IntertidalReefs", "max_forks_repo_head_hexsha": "551c22e29bafe6b01686a833aa881be2b52b6a2a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.5172413793, "max_line_length": 702, "alphanum_fraction": 0.6911522634, "include": true, "reason": "import numpy", "num_tokens": 6130, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46879062662624377, "lm_q2_score": 0.12421300348902359, "lm_q1q2_score": 0.05822989174074717}}
{"text": "r\"\"\".. role:: html(raw)\n   :format: html\n\nUnitary Designs\n===============\n\n.. meta::\n    :property=\"og:description\": Learn about designs and their uses in quantum computing.\n\n    :property=\"og:image\": https://pennylane.ai/qml/_images/fano.png\n\n.. related::\n\n    tutorial_haar_measure Understanding the Haar measure\n\n*Author: PennyLane dev team. Posted: 7 Sept 2021. Last updated: 7 Sept 2021.*\n\n\n.. note::\n\n   This demo is intended to be a sequel to the\n   :doc:`demo about the Haar measure </demos/tutorial_haar_measure>`.\n   If you are not familiar with the Haar measure, we recommend going through\n   that demo first before exploring this one.\n\nTake a close look at the following mathematical object:\n\n.. figure:: /demonstrations/unitary_designs/fano_no_labels.svg\n   :align: center\n   :width: 30%\n\n|\n\nThere are many things we can say about it: it consists of seven points and seven\nlines (the circle counts as a line); each line contains three points, and each\npoint is contained in three lines. Furthermore, any pair of points occur\ntogether in exactly one line. This object, called the `Fano plane\n<https://en.wikipedia.org/wiki/Fano_plane>`__, is an instance of a mathematical\nstructure called a `projective plane\n<https://en.wikipedia.org/wiki/Projective_plane>`__, which is just one example\nof a `combinatorial design\n<https://en.wikipedia.org/wiki/Combinatorial_design>`__. Designs are sets of\nobjects, and groups of those objects, that satisfy certain balance properties\nand symmetries. They have been studied for hundreds of years in a huge variety\nof contexts [#Handbook]_, from `error correcting codes\n<http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.50.5465>`__, to `card\ngames <https://homepages.warwick.ac.uk/staff/D.Maclagan/papers/set.pdf>`__, and\neven `agriculture\n<http://www-groups.mcs.st-and.ac.uk/~rab/histLShand.pdf>`__. So, what about\nquantum computing?\n\nDesigns are actually quite prevalent in quantum computing. You've almost\ncertainly come across one before, though you may not have realized it. At the\nend of the Haar measure demo, we asked a very important question: \"do we always\n*need* to sample from the full Haar measure?\". The answer to this is \"no\", and\nthe reasoning lies in the study of *unitary designs*.\n\nIn this demo, you'll learn the definition of :math:`t`-designs, what it means to\ngeneralize them to unitary :math:`t`-designs, and you'll see some canonical\nexamples of designs in quantum computing. You'll also learn about their\nconnection with the Haar measure, what it means to *twirl* a quantum channel,\nand explore how to leverage 2-designs in PennyLane to compute the average\nfidelity of a noisy channel. You will experience directly a situation where we can\nuse a :math:`t`-design as a shortcut over the full Haar measure to greatly improve\nthe efficiency of a task 🎉.\n\n\nFrom spheres to unitary :math:`t`-designs\n-----------------------------------------\n\nSpherical designs\n^^^^^^^^^^^^^^^^^\n\nBefore diving into unitary designs, let's look at the sphere for some\nintuition.  Suppose we have a polynomial in :math:`d` variables, and we would\nlike to compute its average over the surface of a real, :math:`d`-dimensional\nunit sphere, :math:`S(R^d)`. We can do so by integrating that function over the\nsphere (using the proper measure), but that would be a lot of parameters to\nkeep track of. \n\nOne could alternatively approximate the average by sampling thousands of points\nuniformly at random on the sphere, evaluating the function at those points, and\ncomputing their average value. That will always work, and it will get us close,\nbut it will not be exact.\n\nIn fact, both of those approaches may be overkill in some special cases---if the\nterms in the polynomial have the same degree of at most :math:`t`, you can\ncompute the average **exactly** over the sphere using only a small set of points\nrather than integrating over the entire sphere.  That set of points is called a\nspherical :math:`t`-design. More formally [#Handbook]_, [#Delsarte]_:\n\n.. admonition:: Definition\n    :class: defn\n\n    Let :math:`p_t: \\mathcal{S}(R^d)\\rightarrow R` be a polynomial in :math:`d`\n    variables, with all terms homogeneous in degree at most :math:`t`. A\n    set :math:`X = \\{x: x \\in \\mathcal{S}(R^d)\\}` is a spherical :math:`t`-design if\n\n    .. math::\n\n        \\frac{1}{|X|} \\sum_{x \\in X} p_t(x) = \\int_{\\mathcal{S}(R^d)} p_t (u) d\\mu(u)\n\n    holds for all possible :math:`p_t`, where :math:`d\\mu` is the uniform,\n    normalized spherical measure. A spherical :math:`t`-design is also a\n    :math:`k`-design for all :math:`k < t`.\n\n\n\nNow this is a pretty abstract picture, so let's consider the 3-dimensional\nsphere. This definition tells us that if we want to take the average of a\npolynomial over a sphere where all terms have the same degree of at most 2, we\ncan do so using a small, representative set of points called a 2-design,\nrather than the whole sphere. Similarly, if all terms of the polynomial have the\nsame degree of at most 3, we could use a 3-design. \n\nBut what are these representative sets of points?  Since we are using these\npoints as a stand-in for averaging over the whole sphere, we'd want the points\nin the set to be distributed in a way that provides sufficient \"coverage\". In\nthe 3-dimensional case, the vertices of some familiar solids form :math:`t`-designs\n[#Handbook]_, [#sph4design]_:\n\n.. figure:: /demonstrations/unitary_designs/shapes.svg\n   :align: center\n   :width: 80%\n\n|\n\nWe see from these illustrations that spherical designs are sets of\n*evenly-spaced points*. As :math:`t` increases, the configurations become\nincreasingly sphere-like. Looking at this in a different way, the more complex a\nfunction becomes as its degree increases, the closer the :math:`t`-design must\nbe to a sphere; we need to evaluate the function at more points in order to gain\nsufficient information when a function is varying more quickly due to a higher\ndegree. In 3 dimensions, we can compute the average of a polynomial with degree\n2 by evaluating it only at the points of a tetrahedron, despite the fact that it\ndoesn't look spherical at all. More complex functions require more points\nand thus more intricate configurations for the design.  Spherical designs exist\nfor all :math:`t` and dimension :math:`d` [#Handbook]_. They are not always\nunique, and may have varying numbers of points.\n\nTo show that this really works, let's look at an explicit example. Consider the\nfollowing polynomial in 3 variables:\n\n.. math::\n\n   f(x, y, z) = x^4 - 4 x^3 y + y^2 z^2\n\nWe can compute the average value of :math:`f` by integrating over a unit sphere:\nthe result is :math:`4/15 \\approx 0.26667`. However, this integral is\nnon-trivial to evaluate by hand; the most straightforward way is to convert to\npolar coordinates, and even then, it involves integrating functions with 4th and\n5th powers of trigonometric functions.\n\nInstead, this is a case where we can leverage the fact that all terms in the\npolynomial have degree 4, and compute the average exactly using only a subset of\npoints that form a 4-design. We choose a dodecahedron for convenience; while\nthis is actually a 5 design, it also forms a 4-design, and is a more familiar\nshape than the 4-design depicted above.\n\nFirst, we define the set of points that comprise a dodecahedron:\n\n\"\"\"\n\nimport numpy as np\n\n# The golden ratio\ng = (1 + np.sqrt(5)) / 2\n\n# A dodecahedron has 20 points\ndodecahedron = np.array([\n    # 8 of them form a cube within the sphere\n    [1, 1, 1], [1, 1, -1], [1, -1, 1], [1, -1, -1],\n    [-1, 1, 1], [-1, 1, -1], [-1, -1, 1], [-1, -1, -1],\n\n    # 4 of them form a rectangle within the y-z plane\n    [0, g, 1/g], [0, g, -1/g], [0, -g, 1/g], [0, -g, -1/g],\n\n    # 4 of them form a rectangle within the x-z plane\n    [1/g, 0, g], [1/g, 0, -g], [-1/g, 0, g], [-1/g, 0, -g],\n\n    # 4 of them form a rectangle within the x-y plane\n    [g, 1/g, 0],[g, -1/g, 0], [-g, 1/g, 0], [-g, -1/g, 0],\n])\n\n# Normalize the points so they all fit in the unit sphere\ndodecahedron = np.array(\n   [point / np.linalg.norm(point) for point in dodecahedron]\n)\n\n######################################################################\n# Now we define our function and compute the average over the dodecahedron:\n\ndef f(x, y, z):\n    return (x ** 4) - 4 * (x ** 3) * y +  y ** 2 * z ** 2\n\ndodeca_average = np.mean([f(*point) for point in dodecahedron])\nprint(dodeca_average)\n\n######################################################################\n# This is exactly the value we expect. What happens if we try to do this using\n# only a 3-design, the cube?\n\n# The first 8 points of the dodecahedron are a cube\ncube = dodecahedron[:8]\n\ncube_average = np.mean([f(*point) for point in cube])\nprint(cube_average)\n\n\n######################################################################\n# This clearly differs from the true value. We need a design with :math:`t=4`\n# or better in order to compute this average, and when such a design is\n# available, we may save significant computational time.\n# \n# Unitary designs\n# ^^^^^^^^^^^^^^^\n# \n# We've learned now that spherical designs are sets of evenly-spaced points, and\n# saw how they can be used as a shortcut to evaluate the average of a\n# polynomial up to a given degree :math:`t`. However, there was nothing quantum\n# about this; there weren't even any complex numbers involved. A *unitary\n# design* extends this concept from evenly-distributed points to\n# evenly-distributed unitaries.  More formally, instead of averaging polynomials\n# over spheres, we consider polynomials that are functions of the entries of\n# unitary matrices [#Dankert]_, [#Gross]_.\n# \n# .. admonition:: Definition\n#     :class: defn\n# \n#     Let :math:`P_{t,t}(U)` be a polynomial with homogeneous degree at most :math:`t` in\n#     :math:`d` variables in the entries of a unitary matrix :math:`U`, and degree\n#     :math:`t` in the complex conjugates of those entries. A unitary\n#     :math:`t`-design is a set of :math:`K` unitaries :math:`\\{U_k\\}` such that\n# \n#     .. math::\n# \n#         \\frac{1}{K} \\sum_{k=1}^{K} P_{t,t}(U_k) = \\int_{\\mathcal{U}(d)}\n#         P_{t,t} (U) d\\mu(U)\n# \n#     holds for all possible :math:`P_{t,t}`, and where :math:`d\\mu` is the\n#     uniform *Haar measure*.\n# \n# We stress again that this expression is **exact**. The unitaries in a unitary\n# design are a representative set of points that are \"evenly spaced\" across the\n# unitary group. With just a subset of the full group, we can evaluate complex\n# expressions that would be otherwise intractable.\n# \n# A surprising result about unitary designs is that they exist for all possible\n# combinations of :math:`t` and :math:`d` [#Roy]_. There are some known lower\n# bounds for the number of unitaries required; for example, a 2-design in\n# dimension :math:`d` has at least :math:`d^4 - 2d^2 + 2` elements [#Gross]_,\n# [#Roy]_.  However, actually finding the sets (and in particular, finding ones\n# with minimal size), is a challenging problem [#Bannai]_, though very recently\n# some constructions have been put forward [#Nakata]_.\n#\n#\n# .. admonition:: Fun fact\n#\n#     Applying the elements of a unitary design to a fixed pure state produces a\n#     set of vectors that form a *complex projective design* [#DankertThesis]_.\n#     These are much like spherical designs, but they live in a complex vector\n#     space. If you've ever studied the characterization of quantum systems, you\n#     may have come across some special sets of measurements called mutually\n#     unbiased bases (MUBs), or symmetric, informationally complete positive\n#     operator valued measurements (SIC-POVMs). Both of these sets of vectors\n#     are complex projective 2-designs [#Klappenecker]_.\n#\n#     .. figure:: /demonstrations/unitary_designs/sic-povm.svg\n#        :align: center\n#        :width: 80%\n# \n#        The vectors of the simplest SIC-POVM in dimension 2, plotted on a Bloch sphere.\n#\n# Unitary :math:`t`-designs in action\n# -----------------------------------\n#\n# Unitary designs come into play in applications that require randomization, or\n# sampling of random unitaries---essentially, they can be used as a stand-in for\n# the Haar measure. The way in which the unitaries are used in the application may\n# place restrictions on the value of :math:`t` that is required; arguably the most\n# common is the unitary 2-design.\n#\n# While in general unitary designs are hard to construct, there are well known\n# results for unitary 1-, 2-, and 3-designs based on familiar objects in quantum\n# computing. Before we see what those are, let's explore an important use case.\n#\n# Average fidelity\n# ^^^^^^^^^^^^^^^^\n# A key application of unitary 2-designs is benchmarking quantum\n# operations. Suppose we have a noisy quantum channel :math:`\\Lambda` that should\n# perform something close to the unitary operation :math:`V`.  What can we say\n# about the performance of this channel?\n#\n# One metric of interest is the *fidelity*. Consider the state :math:`|0\\rangle`.\n# In an ideal case, we apply :math:`V` and obtain :math:`V|0\\rangle`.  But applying the\n# channel :math:`\\Lambda` gives us something a little different. Since it's noisy,\n# we must consider the state as a density matrix. The action of :math:`\\Lambda` on\n# our starting state is :math:`\\Lambda(|0\\rangle \\langle 0|)`.  If :math:`\\Lambda`\n# was perfect, then :math:`\\Lambda(|0\\rangle \\langle 0|) = V|0\\rangle \\langle\n# 0|V^\\dagger`, and the fidelity is\n#\n# .. math::\n# \n#     F(\\Lambda, V) = \\langle 0 | V^\\dagger \\cdot \\Lambda(|0\\rangle \\langle 0|) \\cdot V|0\\rangle = 1.\n#\n# In reality, :math:`\\Lambda` is not going to implement :math:`V` perfectly, and\n# :math:`F < 1`. More importantly though, all we've computed so far is the fidelity when\n# the initial state is :math:`|0\\rangle`. What if the initial state is something\n# different? What is the fidelity *on average*?\n# \n# To compute an average fidelity, we must do so with respect to the full set\n# of Haar-random states. We usually generate random states by applying a\n# Haar-random unitary :math:`U` to :math:`|0\\rangle`. Thus to compute the average\n# over all such :math:`U` we must evaluate\n# \n# .. math::\n# \n#     \\bar{F}(\\Lambda, V) = \\int_{\\mathcal{U}} d\\mu(U) \\langle 0 | U^\\dagger V^\\dagger \\Lambda(U |0\\rangle \\langle 0| U^\\dagger) V U |0\\rangle.\n# \n# This is known as *twirling* the channel :math:`\\Lambda`. Computing the average\n# fidelity in this way would be a nightmare---we'd have to compute the fidelity\n# with respect to an infinite number of states!\n# \n# However, consider the expression in the integral above. We have an inner product\n# involving two instances of :math:`U`, and two instances of\n# :math:`U^\\dagger`. This means that the expression is a polynomial of degree 2 in\n# both the elements of :math:`U` and its complex conjugates---this matches exactly\n# the definition of a unitary 2-design. This means that if we can find a set of\n# :math:`K` unitaries that form a 2-design, we can compute the average fidelity\n# using only a finite set of initial states:\n#\n# .. math::\n# \n#     \\frac{1}{K} \\sum_{j=1}^K \\langle 0 | U_j^\\dagger V^\\dagger \\Lambda(U_j |0\\rangle \\langle 0|\n#     U_j^\\dagger) V^\\dagger U_j |0\\rangle = \\int_{\\mathcal{U}} d\\mu(U) \\langle 0\n#     | U^\\dagger V^\\dagger \\Lambda(U |0\\rangle \\langle 0| U^\\dagger) V U |0\\rangle\n#\n# This is great, but a question remains: what is the representative set of unitaries?\n#\n# The Clifford group\n# ^^^^^^^^^^^^^^^^^^\n#\n# A beautiful result in quantum computing is that some special groups you may\n# already be familiar with are unitary designs:\n#\n# - the Pauli group forms a unitary 1-design, and \n# - the Clifford group forms a unitary 3-design. \n#\n# By the definition of designs, this means the Clifford group is also a 1-\n# and 2-design.\n#\n# The :math:`n`-qubit Pauli group, :math:`\\mathcal{P}(n)`, is the set of all tensor\n# products of Pauli operations :math:`X`, :math:`Y`, :math:`Z`, and :math:`I`. The\n# :math:`n`-qubit Clifford group, :math:`\\mathcal{C}(n)`, is the *normalizer* of the\n# Pauli group. In simpler terms, the Clifford group is the set of operations that\n# send Paulis to Paulis (up to a phase) under conjugation i.e.,\n#\n# .. math::\n#\n#    C P C^\\dagger = \\pm P^\\prime, \\quad \\forall P, P^\\prime \\in \\mathcal{P}(n), \\quad C \\in \\mathcal{C}(n).\n#\n# The Clifford group has some profoundly interesting properties and countless uses\n# across quantum computing, from circuit compilation to error correcting\n# codes. For a single qubit, the group is built from just two operations. One is\n# the Hadamard:\n#\n# .. math::\n#\n#    H X H^\\dagger = Z, \\quad H Y H^\\dagger = -Y, \\quad H Z H^\\dagger = X.\n#\n# This clearly maps Paulis to Paulis (up to a phase). The other is the phase gate :math:`S`:\n#\n# .. math::\n#\n#    S X S^\\dagger = Y, \\quad S Y S^\\dagger = -X, \\quad S Z S^\\dagger = Z.\n#\n# If both :math:`H` and :math:`S` map Paulis to Paulis, then products of them do\n# as well. In group theory terms, the single-qubit Clifford group is\n# generated by :math:`H` and :math:`S`.  For example, consider the action of\n# :math:`HS`:\n#\n# .. math::\n#\n#    (HS) X (HS)^\\dagger = -Y, \\quad (HS) Y (HS)^\\dagger = -Z, \\quad (HS) Z (HS)^\\dagger = X.\n#\n# Since :math:`Y = iXZ`, it is enough to specify Clifford operations by how they\n# act on :math:`X` and :math:`Z`.  For a particular Clifford, there are 6 possible\n# ways it can transform :math:`X`, namely :math:`\\pm X, \\pm Y`, or :math:`\\pm Z`.  Once\n# that is determined, there are four remaining options for the transformation of\n# :math:`Z`, leading to 24 elements total.\n#\n# It takes some work, but you can take combinations of :math:`H` and :math:`S`\n# and evaluate their action on :math:`X` and :math:`Z` (or look at their matrix\n# representations) until you find all 24 unique elements. The results of\n# this endeavour are expressed below as strings:\n\nsingle_qubit_cliffords = [\n '',\n 'H', 'S',\n 'HS', 'SH', 'SS',\n 'HSH', 'HSS', 'SHS', 'SSH', 'SSS',\n 'HSHS', 'HSSH', 'HSSS', 'SHSS', 'SSHS',\n 'HSHSS', 'HSSHS', 'SHSSH', 'SHSSS', 'SSHSS',\n 'HSHSSH', 'HSHSSS', 'HSSHSS'\n]\n\n######################################################################\n# To see for yourself how this set of unitaries is evenly distributed, try\n# applying each of the Cliffords to the initial state :math:`|0\\rangle`, and\n# plot the resulting states on the Bloch sphere. You'll find they are\n# symmetric and evenly spaced; in fact, they are all eigenstates of :math:`X`,\n# :math:`Y`, and :math:`Z`. Furthermore, under the full group action, the result\n# is balanced in the sense that each eigenstate is obtained the same number of\n# times.\n#\n# The multi-qubit Clifford group can also be\n# specified by only a small set of generators (in fact, only one more\n# than is needed for the single-qubit case). Together, :math:`H`, :math:`S`, and\n# CNOT (on every possible qubit or pair of qubits) generate the :math:`n`-qubit\n# group. Be careful though---the size of the group increases exponentially. The\n# 2-qubit group alone has 11520 elements! The size can be worked out in a manner\n# analogous to that we used above in the single qubit case: by looking at the\n# combinatorics of the possible ways the gates can map Paulis with only\n# :math:`X` and :math:`Z` to other Paulis.\n#\n# An experiment\n# ^^^^^^^^^^^^^\n# The whole idea of unitary designs may sound too good to be true. Can we\n# *really* compute the exact average fidelity using just 24 operations? In this\n# section, we put them to the test: we'll compute the average fidelity of an\n# operation first with experiments using a large but finite amount of Haar-random\n# unitaries, and then again with only the Clifford group.\n\nimport pennylane as qml\n\n# Scipy allows us to sample Haar-random unitaries directly\nfrom scipy.stats import unitary_group\n\n# set the random seed\nnp.random.seed(42)\n\n# Use the mixed state simulator\ndev = qml.device(\"default.mixed\", wires=1)\n\n######################################################################\n# Let's set up a noisy quantum channel. To keep things simple, assume it\n# consists of applying :class:`~.pennylane.SX`, the square-root of\n# :math:`X` gate, followed by a few different types of noise. First, write a\n# quantum function for our ideal experiment:\n\ndef ideal_experiment():\n    qml.SX(wires=0)\n    return qml.state()\n\n######################################################################\n# Next, we apply some noise. We do so by making use of a relatively new feature\n# in PennyLane called `quantum function transforms <https://pennylane.readthedocs.io/en/latest/code/qml_transforms.html>`__. Such transforms work by\n# modifying the underlying, low-level quantum tapes which queue the quantum\n# operations. Suppose the noisy channel is composed of the following:\n\ndef noisy_operations(damp_factor, depo_factor, flip_prob):\n    qml.AmplitudeDamping(damp_factor, wires=0)\n    qml.DepolarizingChannel(depo_factor, wires=0)\n    qml.BitFlip(flip_prob, wires=0)\n\n\n######################################################################\n# Let's create a transform that applies this noise to any quantum function\n# *after* the original operations, but before the measurements.  We use the\n# convenient :func:`~.pennylane.transforms.qfunc_transform` decorator:\n\n@qml.qfunc_transform\ndef apply_noise(tape, damp_factor, depo_factor, flip_prob):\n    # Apply the original operations\n    for op in tape.operations:\n        qml.apply(op)\n\n    # Apply the noisy sequence\n    noisy_operations(damp_factor, depo_factor, flip_prob)\n\n    # Apply the original measurements\n    for m in tape.measurements:\n        qml.apply(m)\n\n######################################################################\n# We can now apply this transform to create a noisy version of our ideal\n# quantum function:\n\n# The strengths of various types of noise\ndamp_factor = 0.02\ndepo_factor = 0.02\nflip_prob = 0.01\n\nnoisy_experiment = apply_noise(damp_factor, depo_factor, flip_prob)(ideal_experiment)\n\n######################################################################\n# The last part of the experiment involves applying a random unitary matrix\n# before all the operations, and its inverse right before the measurements.  We\n# can write another transform here to streamline this process:\n\n@qml.qfunc_transform\ndef conjugate_with_unitary(tape, matrix):\n    qml.QubitUnitary(matrix, wires=0)\n\n    for op in tape.operations:\n        qml.apply(op)\n\n    qml.QubitUnitary(matrix.conj().T, wires=0)\n\n    for m in tape.measurements:\n        qml.apply(m)\n\n######################################################################\n# Finally, in order to perform a comparison, we need a function to compute the\n# `fidelity <https://en.wikipedia.org/wiki/Fidelity_of_quantum_states>`__\n# compared to the ideal operation.\n\nfrom scipy.linalg import sqrtm\n\ndef fidelity(rho, sigma):\n    # Inputs rho and sigma are density matrices\n    sqrt_sigma = sqrtm(sigma)\n    fid = np.trace(sqrtm(sqrt_sigma @ rho @ sqrt_sigma))\n    return fid.real\n\n######################################################################\n# Let's now compute the average fidelity, averaging over 50000 Haar-random unitaries:\n\nn_samples = 50000\n\nfidelities = []\n\nfor _ in range(n_samples):\n    # Select a Haar-random unitary\n    U = unitary_group.rvs(2)\n\n    # Apply transform to construct the ideal and noisy quantum functions\n    conjugated_ideal_experiment = conjugate_with_unitary(U)(ideal_experiment)\n    conjugated_noisy_experiment = conjugate_with_unitary(U)(noisy_experiment)\n\n    # Use the functions to create QNodes\n    ideal_qnode = qml.QNode(conjugated_ideal_experiment, dev)\n    noisy_qnode = qml.QNode(conjugated_noisy_experiment, dev)\n\n    # Execute the QNodes\n    ideal_state = ideal_qnode()\n    noisy_state = noisy_qnode()\n\n    # Compute the fidelity\n    fidelities.append(fidelity(ideal_state, noisy_state))\n\nfid_mean = np.mean(fidelities)\nprint(f\"Mean fidelity = {fid_mean}\")\n\n######################################################################\n# Now let's repeat the procedure using only Clifford group elements. First, we\n# write a quantum function that performs a Clifford operation (or its inverse)\n# based on its string representation.\n\ndef apply_single_clifford(clifford_string, inverse=False):\n    for gate in clifford_string:\n        if gate == 'H':\n            qml.Hadamard(wires=0)\n        else:\n            sign = -1 if inverse else 1\n            qml.PhaseShift(sign * np.pi/2, wires=0)\n\n######################################################################\n# Next, we write a transform that applies a Clifford in the context of the full\n# experiment, i.e., apply the Clifford, then the operations, followed by the\n# inverse of the Clifford.\n\n@qml.qfunc_transform\ndef conjugate_with_clifford(tape, clifford_string):\n    apply_single_clifford(clifford_string, inverse=False)\n\n    for op in tape.operations:\n        qml.apply(op)\n\n    apply_single_clifford(clifford_string, inverse=True)\n\n    for m in tape.measurements:\n        qml.apply(m)\n\n######################################################################\n# You may have noticed this transform has exactly the same form as\n# ``conjugate_with_unitary`` from above. Only the input type has changed, since\n# the application of Cliffords here is specified by their string representation.\n#\n# It's now time to run the experiments:\n\nfidelities = []\n\nfor C in single_qubit_cliffords:\n    conjugated_ideal_experiment = conjugate_with_clifford(C)(ideal_experiment)\n    conjugated_noisy_experiment = conjugate_with_clifford(C)(noisy_experiment)\n\n    ideal_qnode = qml.QNode(conjugated_ideal_experiment, dev)\n    noisy_qnode = qml.QNode(conjugated_noisy_experiment, dev)\n\n    ideal_state = ideal_qnode()\n    noisy_state = noisy_qnode()\n\n    fidelities.append(fidelity(ideal_state, noisy_state))\n\n######################################################################\n# Let's see how our results compare to the earlier simulation:\n\nclifford_fid_mean = np.mean(fidelities)\n\nprint(f\"Haar-random mean fidelity = {fid_mean}\")\nprint(f\"Clifford mean fidelity    = {clifford_fid_mean}\")\n\n######################################################################\n# Incredible 🤯 🤯 🤯 We were able to compute the average fidelity using only\n# 24 experiments. Furthermore, the mean fidelity obtained from the Clifford\n# experiments is **exact**; even with 50000 Haar-random experiments, we see\n# deviations starting a few decimal places in. Consider the resources that would\n# be saved if you were actually implementing this in a lab! It's not hard to see\n# why the Clifford group plays such an important role in characterization\n# procedures.\n#\n# Conclusion\n# ----------\n#\n# In this demo, we've barely scratched the surface of designs and their\n# applications in quantum computing. While benchmarking is a key application\n# area, there are many others.  The Pauli group as a unitary 1-design has\n# applications in the construction of private quantum channels [#PQC]_.\n# *Approximate* unitary :math:`t`-designs (where the equality in the definition\n# is replaced by approximately equal up to some finite precision) are also of\n# interest, as there ways to construct them that are more efficient than those\n# of exact designs [#Dankert]_. In particular, it has been shown that\n# approximate complex projective 4-designs have applications to the state\n# discrimination problem [#Ambainis]_.\n#\n# Furthermore, unitary designs are not the only designs that you'll encounter\n# in quantum computing. The familiar Hadamard gate is just a 2-dimensional\n# example of a broader family of *Hadamard designs*, on which there has been\n# extensive research [#Seberry]_. Some sets of `mutually orthogonal Latin\n# squares <https://en.wikipedia.org/wiki/Mutually_orthogonal_Latin_squares>`__\n# have a direct correspondence with mutually unbiased bases, which are optimal\n# quantum measurements [#Gaeta]_, as well as complex projective designs; and Latin\n# squares themselves have direct correspondence with affine and projective\n# planes, bringing us full circle back to the Fano plane from which we began.\n#\n#\n# .. figure:: /demonstrations/unitary_designs/affine-latin.svg\n#    :align: center\n#    :width: 80%\n#\n#    An affine plane, Hadamard matrix, and a depiction of mutually orthogonal Latin squares.\n#\n# References\n# ----------\n#\n# .. [#Handbook]\n#\n#     C. J. Colbourn and J. H. Dinitz (2006) *Handbook of Combinatorial Designs,\n#     Second Edition*.  Chapman & Hall/CRC.\n#\n# .. [#Delsarte]\n#\n#    P. Delsarte, J.M. Goethals, J.J. Seidel (1977) *Spherical Codes and Designs*. Geometriae\n#    Dedicata 6 363-388.\n#\n# .. [#sph4design]\n#\n#    R. H. Hardin and N. J. A. Sloane (1992) *New spherical 4-designs*. Discrete\n#    Mathematics, 106-107 (255-264). `(PDF)\n#    <https://www.sciencedirect.com/science/article/pii/0012365X9290552Q>`__.\n#\n# .. [#Ambainis]\n#\n#    A. Ambainis and J. Emerson (2007) *Quantum t-designs: t-wise independence\n#    in the quantum world.* Twenty-Second Annual IEEE Conference on\n#    Computational Complexity 129-140.\n#    `(arXiv) <https://arxiv.org/abs/quant-ph/0701126>`__.\n#\n# .. [#Klappenecker]\n#\n#    A. Klappenecker and M. Roetteler (2005) *Mutually unbiased bases, spherical\n#    designs, and frames.* Proceedings of SPIE Vol. 5914.\n#\n# .. [#Dankert]\n#\n#    C. Dankert, R. Cleve, J. Emerson, and E. Levine (2009) *Exact and\n#    Approximate Unitary 2-Designs: Constructions and Applications.* Phys. Rev. A 80, 012304.\n#    `(arXiv) <https://arxiv.org/abs/quant-ph/0606161>`__.\n#\n# .. [#DankertThesis]\n#\n#    C. Dankert (2005) *Efficient Simulation of Random Quantum States and\n#    Operators.* MSc Thesis, University of Waterloo. `(arXiv)\n#    <https://arxiv.org/abs/quant-ph/0512217>`__.\n#\n# .. [#Gross]\n#\n#    D. Gross, K. Audenaert, and J. Eisert (2007) *Evenly distributed unitaries:\n#    on the structure of unitary designs*. J. Math. Phys. 48, 052104.\n#    `(arXiv) <https://arxiv.org/abs/quant-ph/0611002>`__.\n#\n# .. [#Roy]\n#\n#    A. Roy and A. J. Scott (2009) *Unitary designs and codes*. Des. Codes Cryptogr. 53 13-31.\n#    `(arXiv) <https://arxiv.org/abs/0809.3813>`__.\n#\n# .. [#Bannai]\n#\n#    E. Bannai, M. Nakahara, D. Zhao, and Y. Zhu (2019) *On the explicit constructions of\n#    certain unitary t-designs.* J. Phys. A: Math. Theor. 52 495301.\n#    `(arXiv) <https://arxiv.org/abs/1906.04583>`__.\n#\n# .. [#Nakata]\n#\n#    Y. Nakata et al. (2021) *Quantum circuits for exact unitary t-designs and\n#    applications to higher-order randomized benchmarking.* `(arXiv)\n#    <https://arxiv.org/abs/2102.12617>`__.\n#\n# .. [#PQC]\n#\n#    A. Ambainis, M. Mosca, A. Tapp, and R. de Wolf (2000) *Private Quantum Channels*. Proc.\n#    41st FOCS, 547-553. `(PDF) <https://homepages.cwi.nl/~rdewolf/publ/qc/AMTW00.pdf>`__.\n#\n# .. [#Seberry]\n#\n#    J. Seberry and M. Yamada (1992) *Hadamard matrices, sequences, and block\n#    designs.* Contemporary Design Theory -- A Collection of Surveys\n#    (D. J. Stinson and J. Dinitz, Eds.), John Wiley and Sons, 431-560.\n#    `(PDF) <http://mathscinet.ru/files/YamadaSeberry1992.pdf>`__.\n#\n# .. [#Gaeta]\n#\n#    M. Gaeta, O. Di Matteo, A. B. Klimov, and H. de Guise (2014) *Discrete phase-space\n#    approach to mutually orthogonal Latin squares*. J. Phys. A: Math. Theor. 47 (43) 435303.\n#    `(arXiv) <https://arxiv.org/abs/1408.6742>`__.\n", "meta": {"hexsha": "e1cb0dd9333cbe4a9ceb5bfd1bbbd78f09c2308f", "size": 31218, "ext": "py", "lang": "Python", "max_stars_repo_path": "demonstrations/tutorial_unitary_designs.py", "max_stars_repo_name": "jamesellis1999/qml", "max_stars_repo_head_hexsha": "33c9d66712b36861dc098f9c789ba2c3ab897fdb", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 216, "max_stars_repo_stars_event_min_datetime": "2020-08-01T03:18:37.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T06:17:52.000Z", "max_issues_repo_path": "demonstrations/tutorial_unitary_designs.py", "max_issues_repo_name": "jamesellis1999/qml", "max_issues_repo_head_hexsha": "33c9d66712b36861dc098f9c789ba2c3ab897fdb", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 173, "max_issues_repo_issues_event_min_datetime": "2020-08-05T09:24:15.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T13:37:05.000Z", "max_forks_repo_path": "demonstrations/tutorial_unitary_designs.py", "max_forks_repo_name": "jamesellis1999/qml", "max_forks_repo_head_hexsha": "33c9d66712b36861dc098f9c789ba2c3ab897fdb", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 66, "max_forks_repo_forks_event_min_datetime": "2020-08-01T05:02:45.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-02T19:34:54.000Z", "avg_line_length": 42.3582089552, "max_line_length": 148, "alphanum_fraction": 0.6883208405, "include": true, "reason": "import numpy,from scipy", "num_tokens": 8495, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.37754066879814546, "lm_q2_score": 0.1540575665754383, "lm_q1q2_score": 0.05816299671830579}}
{"text": "# To add a new cell, type '# %%'\n# To add a new markdown cell, type '# %% [markdown]'\n# %% [markdown]\n# # Effect of Heuristic on Search Efficiency\n#\n# This project will show you how to solve planning problems -- Think logistics and scheduling -- using search and logic to find tractable solutions.  Classic planning problems can solve a problem where the rules are known and clear-cut.  In other words, they are _deterministic_.  Where to effects of an action are known to all, in AI, this is known as being _observable_.  In controlled environments, where change only occurs through the actions taken by a planning agent, these systems work well.\n#\n# Acting in these worlds can be modeled logically.  Actions can take place by first meeting all their preconditions.  And once completed, its effects known.  Imagine you are in charge of logistics at Fed Ex and need to find solutions for getting packages from place to place.  How could that be done?  To model the action of flying a package, we can use a [Planning Domain Definition Language](https://planning.wiki/) (PDDL).\n#\n# ```\n# Action(Fly, (plane, from, to)\n#     Precondition: At(plane, from) and Plane(from) and Airport(from) and Airport(to)\n#     Effect: not At(plane, from) and At(plane, to)\n# )\n# ```\n#\n# Propositional logic describes each action briefly.   Just add actions to represent new problems or new business domains.  Knowing that we have a starting state and goal state, a set of actions and costs associated with each action, allows us to apply search algorithms to find solutions.\n#\n\n# %%\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom dataclasses import make_dataclass\n\nsns.set_theme(style=\"whitegrid\")\n\n\n# %%\nRecord = make_dataclass(\n    \"Record\",\n    [\n        (\"Problem\", int),\n        (\"Alg_Num\", int),\n        (\"Alg_Name\", str),\n        (\"Heuristic\", str),\n        (\"Actions\", int),\n        (\"Expansions\", int),\n        (\"Goal_Tests\", int),\n        (\"New_Nodes\", int),\n        (\"Length\", int),\n        (\"Time\", float),\n    ],\n)\n\n# %% [markdown]\n# ## Experimental Results\n#\n# I ran pypy to generate my experiments results using my mac desktop computer.\n\n# %%\ndataset = [\n    Record(1, 1, \"BFS\", \"\", 20, 43, 56, 178, 6, 0.0284),\n    Record(1, 2, \"DFS\", \"\", 20, 21, 22, 84, 20, 0.0073),\n    Record(2, 1, \"BFS\", \"\", 72, 3343, 4609, 30503, 9, 0.3459),\n    Record(2, 2, \"DFS\", \"\", 72, 624, 625, 5602, 619, 0.4810),\n    Record(4, 4, \"Greedy\", \"h_unmet_goals\", 104, 29, 31, 280, 18, 0.0612),\n    Record(\n        4, 11, \"A*\", \"h_pg_setlevel\", 104, 79863, 79865, 768641, 14, 30733.3346,\n    ),\n    Record(\n        3, 11, \"A*\", \"h_pg_setlevel\", 88, 12872, 12874, 115220, 12, 3046.3672\n    ),\n    Record(1, 3, \"UCS\", \"\", 20, 60, 62, 240, 6, 0.0379),\n    Record(1, 4, \"Greedy\", \"h_unmet_goals\", 20, 7, 9, 29, 6, 0.0032),\n    Record(1, 5, \"Greedy\", \"h_pg_levelsum\", 20, 6, 8, 28, 6, 0.4590),\n    Record(1, 6, \"Greedy\", \"h_pg_maxlevel\", 20, 6, 8, 24, 6, 0.1218),\n    Record(1, 7, \"Greedy\", \"h_pg_setlevel\", 20, 13, 15, 53, 6, 1.2660),\n    Record(1, 8, \"A*\", \"h_unmet_goals\", 20, 50, 52, 206, 6, 0.0216),\n    Record(1, 9, \"A*\", \"h_pg_levelsum\", 20, 28, 30, 122, 6, 0.2154),\n    Record(1, 10, \"A*\", \"h_pg_maxlevel\", 20, 43, 45, 180, 6, 0.1616),\n    Record(1, 11, \"A*\", \"h_pg_setlevel\", 20, 46, 48, 192, 6, 0.7168),\n    Record(2, 3, \"UCS\", \"\", 72, 5154, 5156, 46618, 9, 0.7450),\n    Record(2, 4, \"Greedy\", \"h_unmet_goals\", 72, 17, 19, 170, 9, 0.0205),\n    Record(2, 5, \"Greedy\", \"h_pg_levelsum\", 72, 9, 11, 86, 9, 0.4228),\n    Record(2, 6, \"Greedy\", \"h_pg_maxlevel\", 72, 27, 29, 249, 9, 0.6970),\n    Record(2, 7, \"Greedy\", \"h_pg_setlevel\", 72, 304, 306, 2846, 10, 54.8001),\n    Record(2, 8, \"A*\", \"h_unmet_goals\", 72, 2467, 2469, 22522, 9, 0.7026),\n    Record(2, 9, \"A*\", \"h_pg_levelsum\", 72, 357, 359, 3426, 9, 10.3350),\n    Record(2, 10, \"A*\", \"h_pg_maxlevel\", 72, 2887, 2889, 26594, 9, 59.0657),\n    Record(2, 11, \"A*\", \"h_pg_setlevel\", 72, 2879, 2881, 26622, 9, 577.1144),\n    Record(3, 4, \"Greedy\", \"h_unmet_goals\", 88, 25, 27, 230, 15, 0.0519),\n    Record(3, 6, \"Greedy\", \"h_pg_maxlevel\", 88, 21, 23, 195, 13, 1.8522),\n    Record(4, 4, \"Greedy\", \"h_unmet_goals\", 104, 29, 31, 280, 18, 0.0615),\n    Record(4, 6, \"Greedy\", \"h_pg_maxlevel\", 104, 56, 58, 580, 17, 3.6040),\n    Record(3, 8, \"A*\", \"h_unmet_goals\", 88, 7388, 7390, 65711, 12, 1.2993),\n    Record(3, 10, \"A*\", \"h_pg_maxlevel\", 88, 9580, 9582, 86312, 12, 331.0158),\n    Record(4, 8, \"A*\", \"h_unmet_goals\", 104, 34330, 34332, 328509, 14, 4.0136),\n    Record(\n        4, 10, \"A*\", \"h_pg_maxlevel\", 104, 62077, 62079, 599376, 14, 3268.4160\n    ),\n    Record(3, 2, \"DFS\", \"\", 88, 408, 409, 3364, 392, 0.2780),\n    Record(4, 2, \"DFS\", \"\", 104, 25174, 25175, 228849, 24132, 771.7955),\n]\ndf = pd.DataFrame(dataset)\n\n\n# %% [markdown]\n# ---\n#\n# ## Supporting Functions\n\n# %%\ndef create_catplot(df, y_var, title, is_log=True):\n    \"\"\"Creates a categorical plot using Seaborn's catplot.\n    \n    Parameters:\n        df: Dataframe contianing data to be plotted\n        y_var: Name of column in dataframe used for y-axis values\n        title: Title for the plot\n    \"\"\"\n\n    g = sns.catplot(\n        data=df,\n        kind=\"bar\",\n        x=\"Problem\",\n        y=y_var,\n        hue=\"Alg_Title\",\n        height=7,\n        aspect=1.0,\n    )\n    g.despine(left=True, bottom=True)\n    if is_log:\n        g.set(yscale=\"log\")\n    g.ax.xaxis.grid(True, linewidth=0.25)\n    g.ax.yaxis.grid(True, \"minor\", linewidth=0.25)\n    g.despine(left=True, bottom=False)\n    plt.title(title)\n\n\n# %%\ndef create_relplot(df, y_var, title):\n    \"\"\"Creates a relational plot using Seaborn's catplot.\n    \n    Parameters:\n        df: Dataframe contianing data to be plotted\n        y_var: Name of column in dataframe used for y-axis values\n        title: Title for the plot\n    \"\"\"\n\n    g = sns.relplot(\n        data=df,\n        x=\"Actions\",\n        y=y_var,\n        hue=\"Alg_Title\",\n        size=\"Problem\",\n        height=7,\n        aspect=1.0,\n        sizes=(40, 120),\n    )\n    g.set(yscale=\"log\")\n    g.ax.xaxis.grid(True, linewidth=0.25)\n    g.ax.yaxis.grid(True, \"minor\", linewidth=0.25)\n    g.despine(left=True, bottom=False)\n    plt.title(title)\n\n\n# %%\ndf[\"Alg_Title\"] = (\n    df.Alg_Num.astype(str) + \" \" + df[\"Alg_Name\"] + \" \" + df[\"Heuristic\"]\n)\ndf = df.sort_values(by=[\"Problem\", \"Alg_Num\"])\n\n# %% [markdown]\n# ---\n#\n# ## Analysis: Nodes vs Actions\n\n# %%\ncreate_relplot(df, \"New_Nodes\", \"New Nodes vs Actions\")\n\n\n# %%\ncreate_catplot(df, \"New_Nodes\", \"New Nodes by Problem\")\n\n\n# %%\ndf[[\"Problem\", \"Alg_Title\", \"New_Nodes\", \"Actions\"]].set_index(\n    \"Problem\"\n).sort_values(by=[\"Problem\", \"New_Nodes\"])\n\n# %% [markdown]\n# ### Discussion\n#\n# Solving more complex problems requires more actions.  To solve the problems here, the number of actions grows linearly.   Finding the sequence of actions needed to reach the goal requires exponentially more new nodes as problem complexity increases.  When plotted logarithmically, exponential growth appears linearly, just as we see here.  The linear pattern occurs as logarithms and exponents are inverse functions.  One notable exception is the performance of depth-first search on problem 3 is an order of magnitude better than expected.  Repeated runs are consistent, so I imagine it has to do with the structure of the problem that allows DFS to find a solution with minimal backtracking.\n#\n# For all problems and heuristics, greedy algorithms outperform A* by needing fewer nodes to arrive at a solution.  A* has exponential growth in space complexity and puts A* at a disadvantage.  This especially true when the number of actions grows with the increased complexity of the problem.  Breadth-first search algorithms performed the worst -- as expected -- since its frontier size grows exponentially.\n# %% [markdown]\n# ---\n#\n# ## Analysis: Time vs Actions\n#\n\n# %%\ncreate_relplot(df, \"Time\", \"Runtime vs Actions\")\n\n\n# %%\ncreate_catplot(df, \"Time\", \"Runtime vs Actions\")\n\n\n# %%\ndf[[\"Problem\", \"Alg_Title\", \"Time\", \"Actions\"]].set_index(\n    \"Problem\"\n).sort_values(by=[\"Problem\", \"Time\"])\n\n\n# %%\n\n\n# %% [markdown]\n# ### Discussion\n# Greedy search -- especially when using the h_unmet_goals heuristic -- finds solutions the fastest. The h_pg_setlevel heuristic is the slowest for all problems. For problem 1, which only requires 20 actions to solve, greedy search using the h_pg_setlevel is the slowest.  For all other problems, it is A* using this same heuristic. The h_pg_setlevel heuristic estimates:\n#\n# > The set level of a planning graph is the first level where all goals appear such that no pair of goal literals are mutex in the last layer of the planning graph.\n#\n# The h_pg_setlevel heuristic is known to perform poorly on complex problems, and here it lives up to its billing.\n#\n#\n#\n# %% [markdown]\n# ---\n#\n# ## Analysis: Length of plan by algorithm\n#\n#\n\n# %%\ncreate_catplot(df, \"Actions\", \"Actions by Algorithm\", is_log=False)\n\n\n# %%\ndf[[\"Problem\", \"Alg_Title\", \"Actions\"]].set_index(\"Problem\").sort_values(\n    by=[\"Problem\", \"Actions\"]\n)\n\n# %% [markdown]\n# ### Discussion\n#\n# The length of the plan required to arrive at the goal is consistent for all algorithms for each problem. The work to derive the plan -- measured in time expended of new nodes created -- varies considerably across algorithms. Why is this? Conflicting actions have been eliminated by only allowing actions that are not mutually exclusive. Mutually exclusive or mutex actions happen in three different ways.\n#\n# 1. _Inconsistent_ actions negate the effects of one another. For example, `Load(C, p)` and `Unload(C, p)`.\n#\n# 1. _Interference_ s when the effects of one action are mutually exclusive of the precondition of another.  For example, the actions `Fly(a, b)` and `At(a)` are _mutex_ since once flown to airport b.  The plane is no longer at airport a.\n#\n# 1. _Competing needs_ occur when the preconditions of one action interfere with the preconditions of the other.  One plane can only fly to one airport, so the actions `Fly(p, a, b)` and `Fly(P, a, c)` compete for the having the plane `At(a)`.\n#\n# By eliminating mutex actions, the size of the resulting plan shrinks dramatically.\n# %% [markdown]\n# # Questions\n#\n# 1. Which algorithm or algorithms would be most appropriate for planning in a very restricted domain (i.e., one that has only a few actions) and needs to operate in real time?\n#\n# > Based on my analysis of time vs. actions, I would select Greedy h_unmet_goals or DFS because they performed the best for small problems (i.e., problem 1). Both completed their search in less than one-hundredth of a second, an order of magnitude faster than A* h_unmet_goals.\n#\n# 1. _Which algorithm or algorithms would be most appropriate for planning in very large domains (e.g., planning delivery routes for all UPS drivers in the U.S. on a given day)_\n#\n# > Greedy h_unmet_goals is by far the best choice for large problem domains (i.e., problem 4). Other choices are Greedy h_pg_maxlevel or A* h_unmet_goals, but they are three orders of magnitude slower.\n#\n#\n# 1. _Which algorithm or algorithms would be most appropriate for planning problems where it is important to find only optimal plans?\n#\n# > A planning graph is a tree with its root at the initial state. Actions are the branches of the tree and whose effects result in a new state. A* is guaranteed to return an optimal plan when searching a tree using an admissible heuristic. Heuristics are estimates of the cost measured in the number of new states from the initial state. An admissible heuristic will always be less than or equal to the actual cost. Of the heuristics considered in this analysis, here are those that are admissible:\n#\n# * The h_pg_maxlevel. heuristic is the largest level-cost needed to achieve any one of the goal's conditions.\n#\n# * The h_pg_setlevel heuristic is the level where all the goal's conditions are achieved.\n#\n# > __So, to find optimal plans use either A*_h_pg_setlevel heuristic or A*_h_pg_maxlevel. In my results, A_h_pg_setlevel is about 10 faster than A_h_pg_maxlevel for all problems analyzed in this exercise. So, choose A*_h_pg_setlevel. It will return an optimal plan in the least amount of time.__\n#\n# BFS, too, will return an optimal plan but expands an exponentially expanding number of nodes in the process, so it consumes a lot of memory and time.__\n#\n# ### Cite\n#\n# Russell, S. J., & Norvig, P. (2010). Artificial intelligence: A modern approach (3rd ed.). Upper Saddle River: Prentice-Hall.  Chapter 3 - Solving Problems by Searching and Chapter 10 - Classical Planning.\n\n# %%\n\n", "meta": {"hexsha": "4e0393d1a28de04daa734e2a678b3e1c8a34c024", "size": 12578, "ext": "py", "lang": "Python", "max_stars_repo_path": "Projects/2_Classical Planning/report.py", "max_stars_repo_name": "robOcity/artificial-intelligence", "max_stars_repo_head_hexsha": "e2a62bbff99b460fc8362fa9913dbcd4e3edf158", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Projects/2_Classical Planning/report.py", "max_issues_repo_name": "robOcity/artificial-intelligence", "max_issues_repo_head_hexsha": "e2a62bbff99b460fc8362fa9913dbcd4e3edf158", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Projects/2_Classical Planning/report.py", "max_forks_repo_name": "robOcity/artificial-intelligence", "max_forks_repo_head_hexsha": "e2a62bbff99b460fc8362fa9913dbcd4e3edf158", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.9214285714, "max_line_length": 695, "alphanum_fraction": 0.6794402926, "include": true, "reason": "import numpy", "num_tokens": 3776, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3960681662740417, "lm_q2_score": 0.1460872489071524, "lm_q1q2_score": 0.057860508790675357}}
{"text": "r\"\"\"\nInterface to Axiom\n\nTODO:\n\n- Evaluation using a file is not done. Any input line with more than a\n  few thousand characters would hang the system, so currently it\n  automatically raises an exception.\n\n- All completions of a given command.\n\n- Interactive help.\n\nAxiom is a free GPL-compatible (modified BSD license) general\npurpose computer algebra system whose development started in 1973\nat IBM. It contains symbolic manipulation algorithms, as well as\nimplementations of special functions, including elliptic functions\nand generalized hypergeometric functions. Moreover, Axiom has\nimplementations of many functions relating to the invariant theory\nof the symmetric group `S_n.` For many links to Axiom\ndocumentation see http://wiki.axiom-developer.org.\n\nAUTHORS:\n\n- Bill Page (2006-10): Created this (based on Maxima interface)\n\n\n  .. note::\n\n     Bill Page put a huge amount of effort into the Sage Axiom\n     interface over several days during the Sage Days 2 coding\n     sprint. This is contribution is greatly appreciated.\n\n- William Stein (2006-10): misc touchup.\n\n- Bill Page (2007-08): Minor modifications to support axiom4sage-0.3\n\n.. note::\n\n   The axiom4sage-0.3.spkg is based on an experimental version of the\n   FriCAS fork of the Axiom project by Waldek Hebisch that uses\n   pre-compiled cached Lisp code to build Axiom very quickly with\n   clisp.\n\nIf the string \"error\" (case insensitive) occurs in the output of\nanything from axiom, a RuntimeError exception is raised.\n\nEXAMPLES: We evaluate a very simple expression in axiom.\n\n::\n\n    sage: axiom('3 * 5')                     #optional - axiom\n    15\n    sage: a = axiom(3) * axiom(5); a         #optional - axiom\n    15\n\nThe type of a is AxiomElement, i.e., an element of the axiom\ninterpreter.\n\n::\n\n    sage: type(a)                            #optional - axiom\n    <class 'sage.interfaces.axiom.AxiomElement'>\n    sage: parent(a)                          #optional - axiom\n    Axiom\n\nThe underlying Axiom type of a is also available, via the type\nmethod::\n\n    sage: a.type()                           #optional - axiom\n    PositiveInteger\n\nWe factor `x^5 - y^5` in Axiom in several different ways.\nThe first way yields a Axiom object.\n\n::\n\n    sage: F = axiom.factor('x^5 - y^5'); F      #optional - axiom\n               4      3    2 2    3     4\n    - (y - x)(y  + x y  + x y  + x y + x )\n    sage: type(F)                               #optional - axiom\n    <class 'sage.interfaces.axiom.AxiomElement'>\n    sage: F.type()                              #optional - axiom\n    Factored Polynomial Integer\n\nNote that Axiom objects are normally displayed using \"ASCII art\".\n\n::\n\n    sage: a = axiom(2/3); a          #optional - axiom\n      2\n      -\n      3\n    sage: a = axiom('x^2 + 3/7'); a      #optional - axiom\n       2   3\n      x  + -\n           7\n\nThe ``axiom.eval`` command evaluates an expression in\naxiom and returns the result as a string. This is exact as if we\ntyped in the given line of code to axiom; the return value is what\nAxiom would print out.\n\n::\n\n    sage: print axiom.eval('factor(x^5 - y^5)')   #optional - axiom\n               4      3    2 2    3     4\n    - (y - x)(y  + x y  + x y  + x y + x )\n    Type: Factored Polynomial Integer\n\nWe can create the polynomial `f` as a Axiom polynomial,\nthen call the factor method on it. Notice that the notation\n``f.factor()`` is consistent with how the rest of Sage\nworks.\n\n::\n\n    sage: f = axiom('x^5 - y^5')                  #optional - axiom\n    sage: f^2                                     #optional - axiom\n       10     5 5    10\n      y   - 2x y  + x\n    sage: f.factor()                              #optional - axiom\n               4      3    2 2    3     4\n    - (y - x)(y  + x y  + x y  + x y + x )\n\nControl-C interruption works well with the axiom interface, because\nof the excellent implementation of axiom. For example, try the\nfollowing sum but with a much bigger range, and hit control-C.\n\n::\n\n    sage:  f = axiom('(x^5 - y^5)^10000')       # not tested\n    Interrupting Axiom...\n    ...\n    <type 'exceptions.TypeError'>: Ctrl-c pressed while running Axiom\n\n::\n\n    sage: axiom('1/100 + 1/101')                  #optional - axiom\n       201\n      -----\n      10100\n    sage: a = axiom('(1 + sqrt(2))^5'); a         #optional - axiom\n         +-+\n      29\\|2  + 41\n\nTESTS: We check to make sure the subst method works with keyword\narguments.\n\n::\n\n    sage: a = axiom(x+2); a  #optional - axiom\n    x + 2\n    sage: a.subst(x=3)       #optional - axiom\n    5\n\nWe verify that Axiom floating point numbers can be converted to\nPython floats.\n\n::\n\n    sage: float(axiom(2))     #optional - axiom\n    2.0\n\"\"\"\n\n###########################################################################\n#       Copyright (C) 2008 Mike Hansen <mhansen@gmail.com>\n#                     2007 Bill Page\n#                     2006 William Stein <wstein@gmail.com>\n#\n#  Distributed under the terms of the GNU General Public License (GPL)\n#  The full text of the GPL is available at:\n#\n#                  http://www.gnu.org/licenses/\n###########################################################################\n\nimport os, re\n\nfrom expect import Expect, ExpectElement, FunctionElement, ExpectFunction\nfrom sage.misc.misc import verbose, DOT_SAGE\nfrom pexpect import EOF\nfrom sage.misc.multireplace import multiple_replace\n\n# The Axiom commands \")what thing det\" \")show Matrix\" and \")display\n# op det\" commands, gives a list of all identifiers that begin in\n# a certain way.  This could maybe be useful somehow... (?)  Also\n# axiom has a lot a lot of ways for getting documentation from the\n# system -- this could also be useful.\n\nclass PanAxiom(Expect):\n    \"\"\"\n    Interface to a PanAxiom interpreter.\n    \"\"\"\n    def __init__(self, name='axiom', command='axiom -nox -noclef',\n                 script_subdirectory=None, logfile=None,\n                 server=None, server_tmpdir=None,\n                 init_code=[')lisp (si::readline-off)']):\n        \"\"\"\n        Create an instance of the Axiom interpreter.\n\n        TESTS::\n\n            sage: axiom == loads(dumps(axiom))\n            True\n        \"\"\"\n        eval_using_file_cutoff = 200\n        self.__eval_using_file_cutoff = eval_using_file_cutoff\n        self._COMMANDS_CACHE = '%s/%s_commandlist_cache.sobj'%(DOT_SAGE, name)\n        Expect.__init__(self,\n                        name = name,\n                        prompt = '\\([0-9]+\\) -> ',\n                        command = command,\n                        maxread = 10,\n                        script_subdirectory = script_subdirectory,\n                        server=server,\n                        server_tmpdir=server_tmpdir,\n                        restart_on_ctrlc = False,\n                        verbose_start = False,\n                        init_code = init_code,\n                        logfile = logfile,\n                        eval_using_file_cutoff=eval_using_file_cutoff)\n        self._prompt_wait = self._prompt\n\n    def _start(self):\n        \"\"\"\n        Start the Axiom interpreter.\n\n        EXAMPLES::\n\n            sage: a = Axiom()\n            sage: a.is_running()\n            False\n            sage: a._start()     #optional - axiom\n            sage: a.is_running() #optional - axiom\n            True\n            sage: a.quit()       #optional - axiom\n        \"\"\"\n        Expect._start(self)\n        out = self._eval_line(')set functions compile on', reformat=False)\n        out = self._eval_line(')set output length 245', reformat=False)\n        out = self._eval_line(')set message autoload off', reformat=False)\n\n    def _read_in_file_command(self, filename):\n        r\"\"\"\n        EXAMPLES::\n\n            sage: axiom._read_in_file_command('test.input')\n            ')read test.input \\n'\n            sage: axiom._read_in_file_command('test')\n            Traceback (most recent call last):\n            ...\n            ValueError: the filename must end with .input\n\n        ::\n\n            sage: filename = tmp_filename(ext='.input')\n            sage: f = open(filename, 'w')\n            sage: f.write('xx := 22;\\n')\n            sage: f.close()\n            sage: axiom.read(filename)    # optional - axiom\n            sage: axiom.get('xx')         #optional\n            '22'\n        \"\"\"\n        if not filename.endswith('.input'):\n            raise ValueError, \"the filename must end with .input\"\n\n        # For some reason this trivial comp\n        # keeps certain random freezes from occurring.  Do not remove this.\n        # The space before the \\n is also important.\n        return ')read %s \\n'%filename\n\n\n    def _quit_string(self):\n        \"\"\"\n        Returns the string used to quit Axiom.\n\n        EXAMPLES::\n\n            sage: axiom._quit_string()\n            ')lisp (quit)'\n            sage: a = Axiom()\n            sage: a.is_running()\n            False\n            sage: a._start()     #optional - axiom\n            sage: a.is_running() #optional - axiom\n            True\n            sage: a.quit()       #optional - axiom\n            sage: a.is_running() #optional - axiom\n            False\n        \"\"\"\n        return ')lisp (quit)'\n\n    def _commands(self):\n        \"\"\"\n        Returns a list of commands available. This is done by parsing the\n        result of the first section of the output of ')what things'.\n\n        EXAMPLES::\n\n            sage: cmds = axiom._commands() #optional - axiom\n            sage: len(cmds) > 100  #optional - axiom\n            True\n            sage: '<' in cmds      #optional - axiom\n            True\n            sage: 'factor' in cmds #optional - axiom\n            True\n        \"\"\"\n        s = self.eval(\")what things\")\n        start = '\\r\\n\\r\\n#'\n        i = s.find(start)\n        end = \"To get more information about\"\n        j = s.find(end)\n        s = s[i+len(start):j].split()\n        return s\n\n\n    def trait_names(self, verbose=True, use_disk_cache=True):\n        \"\"\"\n        Returns a list of all the commands defined in Axiom and optionally\n        (per default) store them to disk.\n\n        EXAMPLES::\n\n            sage: c = axiom.trait_names(use_disk_cache=False, verbose=False) #optional - axiom\n            sage: len(c) > 100  #optional - axiom\n            True\n            sage: 'factor' in c  #optional - axiom\n            True\n            sage: '**' in c     #optional - axiom\n            False\n            sage: 'upperCase?' in c  #optional - axiom\n            False\n            sage: 'upperCase_q' in c #optional - axiom\n            True\n            sage: 'upperCase_e' in c #optional - axiom\n            True\n        \"\"\"\n        try:\n            return self.__trait_names\n        except AttributeError:\n            import sage.misc.persist\n            if use_disk_cache:\n                try:\n                    self.__trait_names = sage.misc.persist.load(self._COMMANDS_CACHE)\n                    return self.__trait_names\n                except IOError:\n                    pass\n            if verbose:\n                print \"\\nBuilding %s command completion list (this takes\"%(self)\n                print \"a few seconds only the first time you do it).\"\n                print \"To force rebuild later, delete %s.\"%self._COMMANDS_CACHE\n            v = self._commands()\n\n            #Process we now need process the commands to strip out things which\n            #are not valid Python identifiers.\n            import re\n            valid = re.compile('[^a-zA-Z0-9_]+')\n            names = [x for x in v if valid.search(x) is None]\n\n            #Change everything that ends with ? to _q and\n            #everything that ends with ! to _e\n            names += [x[:-1]+\"_q\" for x in v if x.endswith(\"?\")]\n            names += [x[:-1]+\"_e\" for x in v if x.endswith(\"!\")]\n\n            self.__trait_names = names\n            if len(v) > 200:\n                # Axiom is actually installed.\n                sage.misc.persist.save(v, self._COMMANDS_CACHE)\n            return names\n\n    def set(self, var, value):\n        \"\"\"\n        Set the variable var to the given value.\n\n        EXAMPLES::\n\n            sage: axiom.set('xx', '2')    #optional - axiom\n            sage: axiom.get('xx')         #optional - axiom\n            '2'\n\n            sage: fricas.set('xx', '2')    #optional - fricas\n            sage: fricas.get('xx')         #optional - fricas\n            '2'\n\n        \"\"\"\n        cmd = '%s := %s'%(var, value)\n        out = self._eval_line(cmd, reformat=False)\n\n        if out.find(\"error\") != -1:\n            raise TypeError, \"Error executing code in Axiom\\nCODE:\\n\\t%s\\nAxiom ERROR:\\n\\t%s\"%(cmd, out)\n\n\n    def get(self, var):\n        r\"\"\"\n        Get the string value of the Axiom variable var.\n\n        EXAMPLES::\n\n            sage: axiom.set('xx', '2')    #optional - axiom\n            sage: axiom.get('xx')         #optional - axiom\n            '2'\n            sage: a = axiom('(1 + sqrt(2))^5') #optional - axiom\n            sage: axiom.get(a.name())          #optional - axiom\n            '     +-+\\r\\r\\n  29\\\\|2  + 41'\n        \"\"\"\n        s = self._eval_line(str(var))\n        i = s.rfind('Type:')\n        s = s[:i].rstrip().lstrip(\"\\n\")\n        if '\\n' not in s:\n            s = s.strip()\n        return s\n\n    def _eval_line(self, line, reformat=True, allow_use_file=False,\n                   wait_for_prompt=True, restart_if_needed=False):\n        \"\"\"\n        EXAMPLES::\n\n            sage: print axiom._eval_line('2+2')  #optional - axiom\n              4\n                                                       Type: PositiveInteger\n        \"\"\"\n        if not wait_for_prompt:\n            return Expect._eval_line(self, line)\n        line = line.rstrip().rstrip(';')\n        if line == '':\n            return ''\n        if len(line) > 3000:\n            raise NotImplementedError, \"evaluation of long input lines (>3000 characters) in Axiom not yet implemented.\"\n        if self._expect is None:\n            self._start()\n        if allow_use_file and self.__eval_using_file_cutoff and \\\n                            len(line) > self.__eval_using_file_cutoff:\n            return self._eval_line_using_file(line)\n        try:\n            E = self._expect\n            # debug\n            self._synchronize(cmd='1+%s\\n')\n            verbose(\"in = '%s'\"%line,level=3)\n            E.sendline(line)\n            self._expect.expect(self._prompt)\n            out = self._expect.before\n            # debug\n            verbose(\"out = '%s'\"%out,level=3)\n        except EOF:\n          if self._quit_string() in line:\n             return ''\n        except KeyboardInterrupt:\n            self._keyboard_interrupt()\n\n        if '>> Error detected within library code:' in out or \\\n           'Cannot find a definition or applicable library operation named' in out:\n            raise RuntimeError, out\n\n        if not reformat:\n            return out\n        if 'error' in out:\n            return out\n        #out = out.lstrip()\n        i = out.find('\\n')\n        out = out[i+1:]\n        outs = out.split(\"\\n\")\n        i = 0\n        outline = ''\n        for line in outs:\n            line = line.rstrip()\n            # print \"'%s'\"%line\n            if line[:4] == '   (':\n                i = line.find('(')\n                i += line[i:].find(')')\n                if line[i+1:] == \"\":\n                    i = 0\n                    outs = outs[1:]\n                break;\n        out = \"\\n\".join(line[i+1:] for line in outs[1:])\n        return out\n\n    # define relational operators\n    def _equality_symbol(self):\n        \"\"\"equality symbol\n\n        EXAMPLES::\n\n            sage: a = axiom(x==6); a    #optional axiom\n            x= 6\n            sage: a = fricas(x==6); a   #optional fricas\n            x= 6\n        \"\"\"\n        return \"=\"\n\n\nclass Axiom(PanAxiom):\n    def __reduce__(self):\n        \"\"\"\n        EXAMPLES::\n\n            sage: axiom.__reduce__()\n            (<function reduce_load_Axiom at 0x...>, ())\n            sage: f, args = _\n            sage: f(*args)\n            Axiom\n        \"\"\"\n        return reduce_load_Axiom, tuple([])\n\n    def _function_class(self):\n        \"\"\"\n        Return the AxiomExpectFunction class.\n\n        EXAMPLES::\n\n            sage: axiom._function_class()\n            <class 'sage.interfaces.axiom.AxiomExpectFunction'>\n            sage: type(axiom.gcd)\n            <class 'sage.interfaces.axiom.AxiomExpectFunction'>\n        \"\"\"\n        return AxiomExpectFunction\n\n    def _object_class(self):\n        \"\"\"\n        EXAMPLES::\n\n            sage: axiom._object_class()\n            <class 'sage.interfaces.axiom.AxiomElement'>\n            sage: type(axiom(2)) #optional - axiom\n            <class 'sage.interfaces.axiom.AxiomElement'>\n        \"\"\"\n        return AxiomElement\n\n    def _function_element_class(self):\n        \"\"\"\n        Returns the Axiom function element class.\n\n        EXAMPLES::\n\n            sage: axiom._function_element_class()\n            <class 'sage.interfaces.axiom.AxiomFunctionElement'>\n            sage: type(axiom(2).gcd) #optional - axiom\n            <class 'sage.interfaces.axiom.AxiomFunctionElement'>\n        \"\"\"\n        return AxiomFunctionElement\n\n    def console(self):\n        \"\"\"\n        Spawn a new Axiom command-line session.\n\n        EXAMPLES::\n\n            sage: axiom.console() #not tested\n                                    AXIOM Computer Algebra System\n                                    Version: Axiom (January 2009)\n                           Timestamp: Sunday January 25, 2009 at 07:08:54\n            -----------------------------------------------------------------------------\n               Issue )copyright to view copyright notices.\n               Issue )summary for a summary of useful system commands.\n               Issue )quit to leave AXIOM and return to shell.\n            -----------------------------------------------------------------------------\n        \"\"\"\n        axiom_console()\n\nclass PanAxiomElement(ExpectElement):\n    def __call__(self, x):\n        \"\"\"\n        EXAMPLES::\n\n            sage: f = axiom(x+2) #optional - axiom\n            sage: f(2)           #optional - axiom\n            4\n        \"\"\"\n        self._check_valid()\n        P = self.parent()\n        return P('%s(%s)'%(self.name(), x))\n\n    def __cmp__(self, other):\n        \"\"\"\n        EXAMPLES::\n\n            sage: two = axiom(2)  #optional - axiom\n            sage: two == 2        #optional - axiom\n            True\n            sage: two == 3        #optional - axiom\n            False\n            sage: two < 3         #optional - axiom\n            True\n            sage: two > 1         #optional - axiom\n            True\n\n            sage: a = axiom(1); b = axiom(2)  #optional - axiom\n            sage: a == b                      #optional - axiom\n            False\n            sage: a < b                       #optional - axiom\n            True\n            sage: a > b                       #optional - axiom\n            False\n            sage: b < a                       #optional - axiom\n            False\n            sage: b > a                       #optional - axiom\n            True\n\n        We can also compare more complicated object such as functions::\n\n            sage: f = axiom('sin(x)'); g = axiom('cos(x)')    #optional - axiom\n            sage: f == g                                      #optional - axiom\n            False\n\n        \"\"\"\n        P = self.parent()\n        if 'true' in P.eval(\"(%s = %s) :: Boolean\"%(self.name(),other.name())):\n            return 0\n        elif 'true' in P.eval(\"(%s < %s) :: Boolean\"%(self.name(), other.name())):\n            return -1\n        elif 'true' in P.eval(\"(%s > %s) :: Boolean\"%(self.name(),other.name())):\n            return 1\n\n        # everything is supposed to be comparable in Python, so we define\n        # the comparison thus when no comparable in interfaced system.\n        if (hash(self) < hash(other)):\n            return -1\n        else:\n            return 1\n\n    def type(self):\n        \"\"\"\n        Returns the type of an AxiomElement.\n\n        EXAMPLES::\n\n            sage: axiom(x+2).type()  #optional - axiom\n            Polynomial Integer\n        \"\"\"\n        P = self._check_valid()\n        s = P._eval_line(self.name())\n        i = s.rfind('Type:')\n        return P(s[i+5:].strip())\n\n    def __len__(self):\n        \"\"\"\n        Return the length of a list.\n\n        EXAMPLES::\n\n            sage: v = axiom('[x^i for i in 0..5]')            # optional - axiom\n            sage: len(v)                                      # optional - axiom\n            6\n        \"\"\"\n        P = self._check_valid()\n        s = P.eval('# %s '%self.name())\n        i = s.rfind('Type')\n        return int(s[:i-1])\n\n    def __getitem__(self, n):\n        r\"\"\"\n        Return the n-th element of this list.\n\n        .. note::\n\n           Lists are 1-based.\n\n        EXAMPLES::\n\n            sage: v = axiom('[i*x^i for i in 0..5]'); v          # optional - axiom\n                     2   3   4   5\n              [0,x,2x ,3x ,4x ,5x ]\n            sage: v[4]                                           # optional - axiom\n                3\n              3x\n            sage: v[1]                                           # optional - axiom\n            0\n            sage: v[10]                                          # optional - axiom\n            Traceback (most recent call last):\n            ...\n            IndexError: index out of range\n        \"\"\"\n        n = int(n)\n        if n <= 0 or n > len(self):\n            raise IndexError, \"index out of range\"\n        P = self._check_valid()\n        if not isinstance(n, tuple):\n            return P.new('%s(%s)'%(self._name, n))\n        else:\n            return P.new('%s(%s)'%(self._name, str(n)[1:-1]))\n\n    def comma(self, *args):\n        \"\"\"\n        Returns a Axiom tuple from self and args.\n\n        EXAMPLES::\n\n            sage: two = axiom(2)  #optional - axiom\n            sage: two.comma(3)    #optional - axiom\n            [2,3]\n            sage: two.comma(3,4)  #optional - axiom\n            [2,3,4]\n            sage: _.type()        #optional - axiom\n            Tuple PositiveInteger\n\n            sage: two = fricas(2)  #optional - fricas\n            sage: two.comma(3)     #optional - fricas\n            [2,3]\n            sage: two.comma(3,4)   #optional - fricas\n            [2,3,4]\n            sage: _.type()         #optional - fricas\n            Tuple(PositiveInteger)\n\n        \"\"\"\n        P = self._check_valid()\n        args = list(args)\n        for i, arg in enumerate(args):\n            if not isinstance(arg, AxiomElement) or arg.parent() is not P:\n                args[i] = P(arg)\n        cmd = \"(\" + \",\".join([x.name() for x in [self]+args]) + \")\"\n        return P(cmd)\n\n    def _latex_(self):\n        r\"\"\"\n        EXAMPLES::\n\n            sage: a = axiom(1/2) #optional - axiom\n            sage: latex(a)       #optional - axiom\n            \\frac{1}{2}\n\n            sage: a = fricas(1/2) #optional - fricas\n            sage: latex(a)        #optional - fricas\n            1 \\over 2\n        \"\"\"\n        self._check_valid()\n        P = self.parent()\n        s = P._eval_line('outputAsTex(%s)'%self.name(), reformat=False)\n        if not '$$' in s:\n            raise RuntimeError, \"Error texing axiom object.\"\n        i = s.find('$$')\n        j = s.rfind('$$')\n        s = s[i+2:j]\n        s = multiple_replace({'\\r':'', '\\n':' ',\n                              ' \\\\sp ':'^',\n                              '\\\\arcsin ':'\\\\sin^{-1} ',\n                              '\\\\arccos ':'\\\\cos^{-1} ',\n                              '\\\\arctan ':'\\\\tan^{-1} '},\n            re.sub(r'\\\\leqno\\(.*?\\)','',s)) # no eq number!\n        return s\n\n    def as_type(self, type):\n        \"\"\"\n        Returns self as type.\n\n        EXAMPLES::\n\n            sage: a = axiom(1.2); a            #optional - axiom\n            1.2\n            sage: a.as_type(axiom.DoubleFloat) #optional - axiom\n            1.2\n            sage: _.type()                     #optional - axiom\n            DoubleFloat\n\n        ::\n\n            sage: a = fricas(1.2); a            #optional - fricas\n            1.2\n            sage: a.as_type(fricas.DoubleFloat) #optional - fricas\n            1.2\n            sage: _.type()                      #optional - fricas\n            DoubleFloat\n\n        \"\"\"\n        P = self._check_valid()\n        type = P(type)\n        return P.new(\"%s :: %s\"%(self.name(), type.name()))\n\n    def unparsed_input_form(self):\n        \"\"\"\n        Get the linear string representation of this object, if possible\n        (often it isn't).\n\n        EXAMPLES::\n\n            sage: a = axiom(x^2+1); a     #optional - axiom\n               2\n              x  + 1\n            sage: a.unparsed_input_form() #optional - axiom\n            'x*x+1'\n\n            sage: a = fricas(x^2+1)       #optional - fricas\n            sage: a.unparsed_input_form() #optional - fricas\n            'x^2+1'\n        \"\"\"\n        P = self._check_valid()\n        s = P.eval('unparse(%s::InputForm)'%self._name)\n        if 'translation error' in s or 'Cannot convert' in s:\n            raise NotImplementedError\n        s = multiple_replace({'\\r\\n':'', # fix stupid Fortran-ish\n                              'DSIN(':'sin(',\n                              'DCOS(':'cos(',\n                              'DTAN(':'tan(',\n                              'DSINH(':'sinh('}, s)\n        r = re.search(r'\"(.*)\"',s)\n        if r:\n            return r.groups(0)[0]\n        else:\n            return s\n\n\n    def _sage_(self):\n        \"\"\"\n        Convert self to a Sage object.\n\n        EXAMPLES::\n\n            sage: a = axiom(1/2); a #optional - axiom\n              1\n              -\n              2\n            sage: a.sage()          #optional - axiom\n            1/2\n            sage: _.parent()        #optional - axiom\n            Rational Field\n\n            sage: gp(axiom(1/2))    #optional - axiom\n            1/2\n\n            sage: fricas(1/2).sage() #optional - fricas\n            1/2\n\n        DoubleFloat's in Axiom are converted to be in RDF in Sage.\n\n        ::\n\n            sage: axiom(2.0).as_type('DoubleFloat').sage()  #optional - axiom\n            2.0\n            sage: _.parent() #optional - axiom\n            Real Double Field\n\n\n            sage: axiom(2.1234)._sage_() #optional - axiom\n            2.12340000000000\n            sage: _.parent()             #optional - axiom\n            Real Field with 53 bits of precision\n            sage: a = RealField(100)(pi)\n            sage: axiom(a)._sage_()      #optional - axiom\n            3.1415926535897932384626433833\n            sage: _.parent()             #optional - axiom\n            Real Field with 100 bits of precision\n            sage: axiom(a)._sage_() == a #optional - axiom\n            True\n            sage: axiom(2.0)._sage_() #optional - axiom\n            2.00000000000000\n            sage: _.parent() #optional  - axiom\n            Real Field with 53 bits of precision\n\n\n        We can also convert Axiom's polynomials to Sage polynomials.\n            sage: a = axiom(x^2 + 1)   #optional - axiom\n            sage: a.type()             #optional - axiom\n            Polynomial Integer\n            sage: a.sage()             #optional - axiom\n            x^2 + 1\n            sage: _.parent()           #optional - axiom\n            Univariate Polynomial Ring in x over Integer Ring\n            sage: axiom('x^2 + y^2 + 1/2').sage()    #optional - axiom\n            y^2 + x^2 + 1/2\n            sage: _.parent()                         #optional - axiom\n            Multivariate Polynomial Ring in y, x over Rational Field\n\n\n        \"\"\"\n        P = self._check_valid()\n        type = str(self.type())\n\n        if type in [\"Type\", \"Domain\"]:\n            return self._sage_domain()\n\n        if type == \"Float\":\n            from sage.rings.all import RealField, ZZ\n            prec = max(self.mantissa().length()._sage_(), 53)\n            R = RealField(prec)\n            x,e,b = self.unparsed_input_form().lstrip('float(').rstrip(')').split(',')\n            return R(ZZ(x)*ZZ(b)**ZZ(e))\n        elif type == \"DoubleFloat\":\n            from sage.rings.all import RDF\n            return RDF(repr(self))\n        elif type.startswith('Polynomial'):\n            from sage.rings.all import PolynomialRing\n            base_ring = P(type.lstrip('Polynomial '))._sage_domain()\n            vars = str(self.variables())[1:-1]\n            R = PolynomialRing(base_ring, vars)\n            return R(self.unparsed_input_form())\n\n        #If all else fails, try using the unparsed input form\n        try:\n            import sage.misc.sage_eval\n            return sage.misc.sage_eval.sage_eval(self.unparsed_input_form())\n        except StandardError:\n            raise NotImplementedError\n\n\n    def _sage_domain(self):\n        \"\"\"\n        A helper function for converting Axiom domains to the corresponding\n        Sage object.\n\n        EXAMPLES::\n\n            sage: axiom('Integer').sage()  #optional - axiom\n            Integer Ring\n            sage: fricas('Integer').sage() #optional - fricas\n            Integer Ring\n\n            sage: axiom('Fraction Integer').sage()  #optional - axiom\n            Rational Field\n            sage: fricas('Fraction Integer').sage() #optional - fricas\n            Rational Field\n\n            sage: axiom('DoubleFloat').sage()  #optional - axiom\n            Real Double Field\n            sage: fricas('DoubleFloat').sage() #optional - fricas\n            Real Double Field\n\n        \"\"\"\n        P = self._check_valid()\n        name = str(self)\n        if name == 'Integer':\n            from sage.rings.all import ZZ\n            return ZZ\n        elif name == 'DoubleFloat':\n            from sage.rings.all import RDF\n            return RDF\n        elif name.startswith('Fraction '):\n            return P(name.lstrip('Fraction '))._sage_domain().fraction_field()\n\n        raise NotImplementedError\n\n\n\nclass AxiomElement(PanAxiomElement):\n    pass\n\nclass PanAxiomFunctionElement(FunctionElement):\n    def __init__(self, object, name):\n        \"\"\"\n        TESTS::\n\n            sage: a = axiom('\"Hello\"') #optional - axiom\n            sage: a.upperCase_q        #optional - axiom\n            upperCase?\n            sage: a.upperCase_e        #optional - axiom\n            upperCase!\n            sage: a.upperCase_e()      #optional - axiom\n            \"HELLO\"\n        \"\"\"\n        if name.endswith(\"_q\"):\n            name = name[:-2] + \"?\"\n        elif name.endswith(\"_e\"):\n            name = name[:-2] + \"!\"\n        FunctionElement.__init__(self, object, name)\n\nclass AxiomFunctionElement(PanAxiomFunctionElement):\n    pass\n\nclass PanAxiomExpectFunction(ExpectFunction):\n    def __init__(self, parent, name):\n        \"\"\"\n        TESTS::\n\n            sage: axiom.upperCase_q\n            upperCase?\n            sage: axiom.upperCase_e\n            upperCase!\n        \"\"\"\n        if name.endswith(\"_q\"):\n            name = name[:-2] + \"?\"\n        elif name.endswith(\"_e\"):\n            name = name[:-2] + \"!\"\n        ExpectFunction.__init__(self, parent, name)\n\nclass AxiomExpectFunction(PanAxiomExpectFunction):\n    pass\n\ndef is_AxiomElement(x):\n    \"\"\"\n    Returns True of x is of type AxiomElement.\n\n    EXAMPLES::\n\n        sage: from sage.interfaces.axiom import is_AxiomElement\n        sage: is_AxiomElement(axiom(2)) #optional - axiom\n        True\n        sage: is_AxiomElement(2)\n        False\n    \"\"\"\n    return isinstance(x, AxiomElement)\n\n#Instances\naxiom = Axiom(name='axiom')\n\ndef reduce_load_Axiom():\n    \"\"\"\n    Returns the Axiom interface object defined in\n    sage.interfaces.axiom.\n\n    EXAMPLES::\n\n        sage: from sage.interfaces.axiom import reduce_load_Axiom\n        sage: reduce_load_Axiom()\n        Axiom\n    \"\"\"\n    return axiom\n\nimport os\ndef axiom_console():\n    \"\"\"\n    Spawn a new Axiom command-line session.\n\n    EXAMPLES::\n\n        sage: axiom_console() #not tested\n                                AXIOM Computer Algebra System\n                                Version: Axiom (January 2009)\n                       Timestamp: Sunday January 25, 2009 at 07:08:54\n        -----------------------------------------------------------------------------\n           Issue )copyright to view copyright notices.\n           Issue )summary for a summary of useful system commands.\n           Issue )quit to leave AXIOM and return to shell.\n        -----------------------------------------------------------------------------\n\n    \"\"\"\n    os.system('axiom -nox')\n\n", "meta": {"hexsha": "0ac5d58f9104acbe0e013f85538fa5b37079e2a2", "size": 32335, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/interfaces/axiom.py", "max_stars_repo_name": "bopopescu/sage-5", "max_stars_repo_head_hexsha": "9d85b34956ca2edd55af307f99c5d3859acd30bf", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-08-20T00:30:35.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-17T10:54:00.000Z", "max_issues_repo_path": "src/sage/interfaces/axiom.py", "max_issues_repo_name": "bopopescu/sage-5", "max_issues_repo_head_hexsha": "9d85b34956ca2edd55af307f99c5d3859acd30bf", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/interfaces/axiom.py", "max_forks_repo_name": "bopopescu/sage-5", "max_forks_repo_head_hexsha": "9d85b34956ca2edd55af307f99c5d3859acd30bf", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.5463414634, "max_line_length": 120, "alphanum_fraction": 0.5015617752, "include": true, "reason": "import sage,from sage", "num_tokens": 7690, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4843800842769844, "lm_q2_score": 0.11920292202211755, "lm_q1q2_score": 0.0577395214151361}}
{"text": "from sympy.core.basic import Basic\nfrom sympy.printing import pprint\n\nimport random\n\ndef interactive_traversal(expr):\n    \"\"\"Traverse a tree asking a user which branch to choose. \"\"\"\n\n    RED, BRED = '\\033[0;31m', '\\033[1;31m'\n    GREEN, BGREEN = '\\033[0;32m', '\\033[1;32m'\n    YELLOW, BYELLOW = '\\033[0;33m', '\\033[1;33m'  # noqa\n    BLUE, BBLUE = '\\033[0;34m', '\\033[1;34m'      # noqa\n    MAGENTA, BMAGENTA = '\\033[0;35m', '\\033[1;35m'# noqa\n    CYAN, BCYAN = '\\033[0;36m', '\\033[1;36m'      # noqa\n    END = '\\033[0m'\n\n    def cprint(*args):\n        print(\"\".join(map(str, args)) + END)\n\n    def _interactive_traversal(expr, stage):\n        if stage > 0:\n            print()\n\n        cprint(\"Current expression (stage \", BYELLOW, stage, END, \"):\")\n        print(BCYAN)\n        pprint(expr)\n        print(END)\n\n        if isinstance(expr, Basic):\n            if expr.is_Add:\n                args = expr.as_ordered_terms()\n            elif expr.is_Mul:\n                args = expr.as_ordered_factors()\n            else:\n                args = expr.args\n        elif hasattr(expr, \"__iter__\"):\n            args = list(expr)\n        else:\n            return expr\n\n        n_args = len(args)\n\n        if not n_args:\n            return expr\n\n        for i, arg in enumerate(args):\n            cprint(GREEN, \"[\", BGREEN, i, GREEN, \"] \", BLUE, type(arg), END)\n            pprint(arg)\n            print()\n\n        if n_args == 1:\n            choices = '0'\n        else:\n            choices = '0-%d' % (n_args - 1)\n\n        try:\n            choice = input(\"Your choice [%s,f,l,r,d,?]: \" % choices)\n        except EOFError:\n            result = expr\n            print()\n        else:\n            if choice == '?':\n                cprint(RED, \"%s - select subexpression with the given index\" %\n                       choices)\n                cprint(RED, \"f - select the first subexpression\")\n                cprint(RED, \"l - select the last subexpression\")\n                cprint(RED, \"r - select a random subexpression\")\n                cprint(RED, \"d - done\\n\")\n\n                result = _interactive_traversal(expr, stage)\n            elif choice in ('d', ''):\n                result = expr\n            elif choice == 'f':\n                result = _interactive_traversal(args[0], stage + 1)\n            elif choice == 'l':\n                result = _interactive_traversal(args[-1], stage + 1)\n            elif choice == 'r':\n                result = _interactive_traversal(random.choice(args), stage + 1)\n            else:\n                try:\n                    choice = int(choice)\n                except ValueError:\n                    cprint(BRED,\n                           \"Choice must be a number in %s range\\n\" % choices)\n                    result = _interactive_traversal(expr, stage)\n                else:\n                    if choice < 0 or choice >= n_args:\n                        cprint(BRED, \"Choice must be in %s range\\n\" % choices)\n                        result = _interactive_traversal(expr, stage)\n                    else:\n                        result = _interactive_traversal(args[choice], stage + 1)\n\n        return result\n\n    return _interactive_traversal(expr, 0)\n", "meta": {"hexsha": "1315ec4ef7868b666bb6b978b3d8b20442d100b0", "size": 3189, "ext": "py", "lang": "Python", "max_stars_repo_path": "sympy/interactive/traversal.py", "max_stars_repo_name": "utkarshdeorah/sympy", "max_stars_repo_head_hexsha": "dcdf59bbc6b13ddbc329431adf72fcee294b6389", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8323, "max_stars_repo_stars_event_min_datetime": "2015-01-02T15:51:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T13:13:19.000Z", "max_issues_repo_path": "sympy/interactive/traversal.py", "max_issues_repo_name": "utkarshdeorah/sympy", "max_issues_repo_head_hexsha": "dcdf59bbc6b13ddbc329431adf72fcee294b6389", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 15102, "max_issues_repo_issues_event_min_datetime": "2015-01-01T01:33:17.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T22:53:13.000Z", "max_forks_repo_path": "sympy/interactive/traversal.py", "max_forks_repo_name": "utkarshdeorah/sympy", "max_forks_repo_head_hexsha": "dcdf59bbc6b13ddbc329431adf72fcee294b6389", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4490, "max_forks_repo_forks_event_min_datetime": "2015-01-01T17:48:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T17:24:05.000Z", "avg_line_length": 33.21875, "max_line_length": 80, "alphanum_fraction": 0.4898087175, "include": true, "reason": "from sympy", "num_tokens": 775, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44552954976388504, "lm_q2_score": 0.12940273159163906, "lm_q1q2_score": 0.05765274074423982}}
{"text": "import numpy as np\n\na = np.arange(10) * 10\nprint(a)\n# [ 0 10 20 30 40 50 60 70 80 90]\n\nprint(a[5])\n# 50\n\nprint(a[8])\n# 80\n\nprint(a[[5, 8]])\n# [50 80]\n\nprint(a[[5, 4, 8, 0]])\n# [50 40 80  0]\n\nprint(a[[5, 5, 5, 5]])\n# [50 50 50 50]\n\nidx = np.array([[5, 4], [8, 0]])\nprint(idx)\n# [[5 4]\n#  [8 0]]\n\nprint(a[idx])\n# [[50 40]\n#  [80  0]]\n\n# print(a[[[5, 4], [8, 0]]])\n# IndexError: too many indices for array\n\nprint(a[[[[5, 4], [8, 0]]]])\n# [[50 40]\n#  [80  0]]\n\na_2d = np.arange(12).reshape((3, 4))\nprint(a_2d)\n# [[ 0  1  2  3]\n#  [ 4  5  6  7]\n#  [ 8  9 10 11]]\n\nprint(a_2d[0])\n# [0 1 2 3]\n\nprint(a_2d[2])\n# [ 8  9 10 11]\n\nprint(a_2d[[2, 0]])\n# [[ 8  9 10 11]\n#  [ 0  1  2  3]]\n\nprint(a_2d[[2, 2, 2]])\n# [[ 8  9 10 11]\n#  [ 8  9 10 11]\n#  [ 8  9 10 11]]\n\nprint(a_2d[:, 1])\n# [1 5 9]\n\nprint(a_2d[:, 3])\n# [ 3  7 11]\n\nprint(a_2d[:, 1:2])\n# [[1]\n#  [5]\n#  [9]]\n\nprint(a_2d[:, [3, 1]])\n# [[ 3  1]\n#  [ 7  5]\n#  [11  9]]\n\nprint(a_2d[:, [3, 3, 3]])\n# [[ 3  3  3]\n#  [ 7  7  7]\n#  [11 11 11]]\n\nprint(a_2d[0, 1])\n# 1\n\nprint(a_2d[2, 3])\n# 11\n\nprint(a_2d[[0, 2], [1, 3]])\n# [ 1 11]\n\n# index\n# [[0, 1] [2, 3]]\n\n# print(a_2d[[0, 2, 1], [1, 3]])\n# IndexError: shape mismatch: indexing arrays could not be broadcast together with shapes (3,) (2,) \n\nprint(a_2d[[[0, 0], [2, 2]], [[1, 3], [1, 3]]])\n# [[ 1  3]\n#  [ 9 11]]\n\n# index\n# [[0, 1] [0, 3]\n#  [2, 1] [2, 3]]\n\nprint(a_2d[[[0], [2]], [1, 3]])\n# [[ 1  3]\n#  [ 9 11]]\n\nidxs = np.ix_([0, 2], [1, 3])\nprint(idxs)\n# (array([[0],\n#        [2]]), array([[1, 3]]))\n\nprint(type(idxs))\n# <class 'tuple'>\n\nprint(type(idxs[0]))\n# <class 'numpy.ndarray'>\n\nprint(idxs[0])\n# [[0]\n#  [2]]\n\nprint(idxs[1])\n# [[1 3]]\n\nprint(a_2d[np.ix_([0, 2], [1, 3])])\n# [[ 1  3]\n#  [ 9 11]]\n\nprint(a_2d[np.ix_([2, 0], [3, 3, 3])])\n# [[11 11 11]\n#  [ 3  3  3]]\n\nprint(a_2d[[0, 2]][:, [1, 3]])\n# [[ 1  3]\n#  [ 9 11]]\n\na_2d = np.arange(12).reshape((3, 4))\nprint(a_2d)\n# [[ 0  1  2  3]\n#  [ 4  5  6  7]\n#  [ 8  9 10 11]]\n\na_2d[np.ix_([0, 2], [1, 3])] = 100\nprint(a_2d)\n# [[  0 100   2 100]\n#  [  4   5   6   7]\n#  [  8 100  10 100]]\n\na_2d[np.ix_([0, 2], [1, 3])] = [100, 200]\nprint(a_2d)\n# [[  0 100   2 200]\n#  [  4   5   6   7]\n#  [  8 100  10 200]]\n\na_2d[np.ix_([0, 2], [1, 3])] = [[100, 200], [300, 400]]\nprint(a_2d)\n# [[  0 100   2 200]\n#  [  4   5   6   7]\n#  [  8 300  10 400]]\n\nprint(a_2d[[0, 2]][:, [1, 3]])\n# [[100 200]\n#  [300 400]]\n\na_2d[[0, 2]][:, [1, 3]] = 0\nprint(a_2d)\n# [[  0 100   2 200]\n#  [  4   5   6   7]\n#  [  8 300  10 400]]\n\na_2d = np.arange(12).reshape((3, 4))\nprint(a_2d)\n# [[ 0  1  2  3]\n#  [ 4  5  6  7]\n#  [ 8  9 10 11]]\n\na_2d[[2, 0]] = [[100, 200, 300, 400], [500, 600, 700, 800]]\nprint(a_2d)\n# [[500 600 700 800]\n#  [  4   5   6   7]\n#  [100 200 300 400]]\n\na_2d[[2, 2]] = [[-1, -2, -3, -4], [-5, -6, -7, -8]]\nprint(a_2d)\n# [[500 600 700 800]\n#  [  4   5   6   7]\n#  [ -5  -6  -7  -8]]\n\na_2d = np.arange(12).reshape((3, 4))\nprint(a_2d)\n# [[ 0  1  2  3]\n#  [ 4  5  6  7]\n#  [ 8  9 10 11]]\n\na_fancy = a_2d[np.ix_([0, 2], [1, 3])]\nprint(a_fancy)\n# [[ 1  3]\n#  [ 9 11]]\n\na_fancy[0, 0] = 100\nprint(a_fancy)\n# [[100   3]\n#  [  9  11]]\n\nprint(a_2d)\n# [[ 0  1  2  3]\n#  [ 4  5  6  7]\n#  [ 8  9 10 11]]\n\na_2d = np.arange(12).reshape((3, 4))\nprint(a_2d)\n# [[ 0  1  2  3]\n#  [ 4  5  6  7]\n#  [ 8  9 10 11]]\n\nprint(a_2d[[2, 0], ::-1])\n# [[11 10  9  8]\n#  [ 3  2  1  0]]\n\nprint(a_2d[::2, [3, 0, 1]])\n# [[ 3  0  1]\n#  [11  8  9]]\n", "meta": {"hexsha": "80ac5a168bf65c3fed963bb141c8083c0168965f", "size": 3347, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebook/numpy_fancy_indexing.py", "max_stars_repo_name": "vhn0912/python-snippets", "max_stars_repo_head_hexsha": "80b2e1d6b2b8f12ae30d6dbe86d25bb2b3a02038", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 174, "max_stars_repo_stars_event_min_datetime": "2018-05-30T21:14:50.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T07:59:37.000Z", "max_issues_repo_path": "notebook/numpy_fancy_indexing.py", "max_issues_repo_name": "vhn0912/python-snippets", "max_issues_repo_head_hexsha": "80b2e1d6b2b8f12ae30d6dbe86d25bb2b3a02038", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2019-08-10T03:22:02.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-12T20:31:17.000Z", "max_forks_repo_path": "notebook/numpy_fancy_indexing.py", "max_forks_repo_name": "vhn0912/python-snippets", "max_forks_repo_head_hexsha": "80b2e1d6b2b8f12ae30d6dbe86d25bb2b3a02038", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 53, "max_forks_repo_forks_event_min_datetime": "2018-04-27T05:26:35.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-25T07:59:37.000Z", "avg_line_length": 15.0089686099, "max_line_length": 100, "alphanum_fraction": 0.4320286824, "include": true, "reason": "import numpy", "num_tokens": 1962, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.12085323090725615, "lm_q1q2_score": 0.05759619061569799}}
{"text": "# encoding: UTF-8\r\n\r\n'''\r\n本文件中包含的是遗传算法参数优化器的实现\r\n华富资产 李来佳\r\n'''\r\n\r\n\r\nfrom typing import Callable, List\r\nfrom itertools import product\r\nfrom functools import lru_cache\r\nfrom time import time\r\nfrom datetime import  datetime\r\nimport multiprocessing\r\nimport random\r\nimport traceback\r\nfrom copy import copy, deepcopy\r\nfrom uuid import uuid1\r\nimport logging\r\nimport os\r\nimport numpy as np\r\n\r\n# deap是遗传算法的实现工具\r\nfrom deap import creator, base, tools, algorithms\r\n\r\nfrom vnpy.app.cta_strategy_pro.portfolio_testing import PortfolioTestingEngine\r\nfrom vnpy.trader.util_logger import setup_logger\r\n\r\nclass OptimizationSetting:\r\n    \"\"\"\r\n    Setting for runnning optimization.\r\n    设置参数优化\r\n    \"\"\"\r\n\r\n    def __init__(self):\r\n        \"\"\"\"\"\"\r\n        self.params = {}\r\n        self.target_name = \"\"\r\n\r\n    def add_parameter(\r\n            self, name: str,\r\n            start: float,\r\n            end: float = None,\r\n            step: float = None\r\n    ):\r\n        \"\"\"添加int/float类型参数优化\"\"\"\r\n        if not end and not step:\r\n            self.params[name] = [start]\r\n            return\r\n\r\n        if start >= end:\r\n            print(\"参数优化起始点必须小于终止点\")\r\n            return\r\n\r\n        if step <= 0:\r\n            print(\"参数优化步进必须大于0\")\r\n            return\r\n\r\n        value = start\r\n        value_list = []\r\n\r\n        while value <= end:\r\n            value_list.append(value)\r\n            value += step\r\n\r\n        # win: [20,22,24]\r\n        self.params[name] = value_list\r\n\r\n    def add_parameters(self,\r\n                       name: str,\r\n                       values: List = []):\r\n        \"\"\"添加参数清单\"\"\"\r\n        self.params[name] = values\r\n\r\n    def set_target(self, target_name: str):\r\n        \"\"\"\"\"\"\r\n        self.target_name = target_name\r\n\r\n    def generate_setting(self) -> List:\r\n        \"\"\"\"\"\"\r\n        keys = self.params.keys()\r\n        values = self.params.values()\r\n        products = list(product(*values))\r\n\r\n        settings = []\r\n        for p in products:\r\n            setting = dict(zip(keys, p))\r\n            settings.append(setting)\r\n\r\n        return settings\r\n\r\n    def generate_setting_ga(self):\r\n        \"\"\"\"\"\"\r\n        settings_ga = []  # [ [(key1:value1), (key2:value2)], [],,,]\r\n        settings = self.generate_setting()\r\n        for d in settings:\r\n            # dict => [(key1:value1), (key2:value2)]\r\n            param = [tuple(i) for i in d.items()]\r\n            settings_ga.append(param)\r\n        return settings_ga\r\n\r\n\r\nclass GeneticOptimize(object):\r\n    \"\"\"\r\n    遗传算法优化器\r\n    \"\"\"\r\n    def __init__(self):\r\n\r\n        self.s = OptimizationSetting()  # 参数生成器\r\n        self.be = PortfolioTestingEngine()  # (组合)回测引擎\r\n\r\n        self.settings_for_ga = []  # 供遗传算法进行优化的参数列表\r\n        self.settings_for_env = {}  # 供回测使用的参数配置，如合约、资金账号、回测时间等\r\n        self.settings_for_strategies = {}  # cta_strategy_settings， dict格式：{ \"strategy_instance_name\": {策略配置}}\r\n\r\n        self.target_names = []  # 回测结果目标值名称列表，如最大化收益回撤比，最大化夏普比率\r\n        self.logger = None\r\n\r\n    creator.create(\"FitnessMulti\", base.Fitness, weights=(1.0, 1.0))\r\n    creator.create(\"Individual\", list, fitness=creator.FitnessMulti)\r\n\r\n    def write_log(self,msg: str, level: int = logging.DEBUG):\r\n\r\n        if self.logger:\r\n            self.logger.log(msg=msg, level=level)\r\n\r\n    def init_setting(self,\r\n                     test_settings,\r\n                     strategy_settings,\r\n                     target_names):\r\n\r\n        # 回测引擎所需的所有基本配置\r\n        self.settings_for_env = deepcopy(test_settings)\r\n\r\n        if not self.logger:\r\n            logs_folder = os.path.abspath(os.path.join(os.getcwd(), 'log'))\r\n            filename = os.path.abspath(os.path.join(logs_folder, '{}'.format(test_settings['name'])))\r\n            self.logger = setup_logger(file_name=filename,\r\n                                       name=\"go_{}\".format(datetime.now().strftime(\"%Y%m%d_%H%M%S\")),\r\n                                       log_level=logging.DEBUG,\r\n                                       backtesing=True)\r\n\r\n        # 回测实例及配置\r\n        self.settings_for_strategies = deepcopy(strategy_settings)\r\n\r\n        # 优化的目标值清单\r\n        self.target_names = deepcopy(target_names)\r\n\r\n        return self.settings_for_env\r\n\r\n    def add_parameter(self, name, start, end, step):\r\n        \"\"\"\r\n        添加参数\r\n        :param name: 参数名称\r\n        :param start: 开始数字\r\n        :param end: 结束数字\r\n        :param step: 步进\r\n        :return:\r\n        \"\"\"\r\n        self.s.add_parameter(name, start, end, step)\r\n\r\n    def add_parameters(self, name, values):\r\n        \"\"\"\r\n        添加参数\r\n        :param name: 参数名\r\n        :param values: 参数值列表\r\n        :return:\r\n        \"\"\"\r\n        self.s.add_parameters(name, deepcopy(values))\r\n\r\n    def generate_setting_for_ga(self):\r\n        \"\"\"\r\n        产生遗传算法的参数列表\r\n        :return:\r\n        \"\"\"\r\n        settings = self.s.generate_setting()\r\n        for d in settings:\r\n            param = [tuple(i) for i in d.items()]\r\n            self.settings_for_ga.append(param)\r\n        return self.settings_for_ga\r\n\r\n    def generate_parameter(self):\r\n        \"\"\"\"\"\"\r\n        return random.choice(self.settings_for_ga)\r\n\r\n    def mutArrayGroup(self, individual, indpb):\r\n        size = len(individual)\r\n        paralist = self.generate_parameter()\r\n        for i in range(size):\r\n            if random.random() < indpb:\r\n                individual[i] = paralist[i]\r\n        return individual,\r\n\r\n    def object_func(self, strategy_avg):\r\n        \"\"\"\r\n        遗传优化的目标执行函数\r\n        :param strategy_avg:\r\n        :return:\r\n        \"\"\"\r\n        return self._object_func(tuple(strategy_avg))\r\n\r\n    def optimize(self):\r\n        \"\"\"\r\n        运行优化\r\n        :return:\r\n        \"\"\"\r\n        start = time()\r\n        toolbox = base.Toolbox()\r\n\r\n        # 使用多进程\r\n        pool = multiprocessing.Pool(multiprocessing.cpu_count())\r\n        toolbox.register(\"map\", pool.map)\r\n        # 初始化\r\n        toolbox.register(\"individual\", tools.initIterate, creator.Individual, self.generate_parameter)\r\n        toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\r\n        toolbox.register(\"mate\", tools.cxTwoPoint)\r\n        toolbox.register(\"mutate\", self.mutArrayGroup, indpb=1)\r\n        toolbox.register(\"evaluate\", self.object_func)\r\n        toolbox.register(\"select\", tools.selNSGA2)\r\n\r\n        MU = 16\r\n        LAMBDA = 20\r\n        POP = 20\r\n        pop = toolbox.population(POP)\r\n        CXPB, MUTPB, NGEN = 0.95, 0.05, 4\r\n        hof = tools.ParetoFront()\r\n\r\n        stats = tools.Statistics(lambda ind: ind.fitness.values)\r\n        np.set_printoptions(suppress=True)\r\n        stats.register(\"mean\", np.mean, axis=0)\r\n        stats.register(\"std\", np.std, axis=0)\r\n        stats.register(\"min\", np.min, axis=0)\r\n        stats.register(\"max\", np.max, axis=0)\r\n\r\n        self.write_log(\"开始运行遗传算法，每代族群总数：%s, 优良品种筛选个数：%s，迭代次数：%s，交叉概率：%s，突变概率：%s\" % (POP, MU, NGEN, CXPB, MUTPB))\r\n        algorithms.eaMuPlusLambda(pop, toolbox, MU, LAMBDA, CXPB, MUTPB, NGEN, stats, halloffame=hof, verbose=True)\r\n        end = time()\r\n        cost = int((end - start))\r\n\r\n        self.write_log(\"遗传算法优化完成，耗时%s秒\" % (cost))\r\n        self.write_log(\"----------输出帕累托前沿解集,解集数量%s----------\" % (len(hof)))\r\n        # return hof\r\n        for i in range(len(hof)):\r\n            solution = hof[i]\r\n            self.write_log(solution)\r\n\r\n\r\n    @lru_cache(maxsize=1000000)\r\n    def _object_func(self, strategy_avg):\r\n        \"\"\"\r\n        使用了缓存，可以减少重复参数的运行\r\n        :param strategy_avg: 选取的策略参数\r\n        :return:\r\n        \"\"\"\r\n        engine = self.be\r\n        self.settings_for_env['name'] = self.settings_for_env['name'] + '_' + str(uuid1())\r\n        engine.prepare_env(self.settings_for_env)\r\n        # 选取参数 => dict 结构\r\n        ga_setting = dict(strategy_avg)\r\n        settings_for_strategies = deepcopy(self.settings_for_strategies)\r\n\r\n        # 策略实例名\r\n        for ins_name in list(settings_for_strategies.keys()):\r\n            # 策略实例配置\r\n            ins_config = settings_for_strategies[ins_name]\r\n            # 策略实例的策略参数\r\n            strategy_setting = ins_config['setting']\r\n            # 候选参数值 => 更新 => 策略参数值\r\n            for k, v in ga_setting.items():\r\n                if k in strategy_setting:\r\n                    strategy_setting.update({k: v})\r\n            # 更新回测实例配置\r\n            settings_for_strategies.update({ins_name: ins_config})\r\n\r\n        try:\r\n            # 运行（组合）回测\r\n            engine.run_portfolio_test(settings_for_strategies)\r\n            # 回测结果，保存\r\n            result = engine.show_backtesting_result()\r\n\r\n            # 保存策略得内部数据\r\n            engine.save_strategy_data()\r\n\r\n            # 根据target_names => (value1, value2)\r\n            return tuple([round(result.get(k, 0), 2) for k in self.target_names])\r\n\r\n        except Exception as ex:\r\n            self.write_log('组合回测异常{}'.format(str(ex)))\r\n            traceback.print_exc()\r\n            engine.save_fail_to_mongo(f'回测异常{str(ex)}')\r\n            return tuple([0 for k in self.target_names])\r\n\r\n\r\ndef run_go(test_setting: dict, strategy_setting: dict, ga_setting: dict, target_names: List):\r\n    \"\"\"\r\n    遗传算法优化+回测\r\n    : test_setting, 组合回测所需的配置，包括合约信息，数据bar信息，回测时间，资金等。\r\n    ：strategy_setting, dict, 一个或多个策略配置\r\n    : ga_setting,dict, 代优化参数的设定： name: (开始值，结束值，步进）, name: [value1, value2,value3,,,]\r\n\r\n    : return 定义的\r\n    \"\"\"\r\n    # 创建遗传优化器\r\n    GO = GeneticOptimize()\r\n\r\n    # 初始化 环境参数、策略参数，优化目标清单\r\n    GO.init_setting(\r\n        test_settings=test_setting,\r\n        strategy_settings=strategy_setting,\r\n        target_names=target_names\r\n    )\r\n\r\n    # 添加代优化的参数\r\n    for k, v in ga_setting.items():\r\n        if isinstance(v, tuple) and len(v) == 3:\r\n            GO.add_parameter(k, v[0], v[1], v[2])\r\n\r\n        if isinstance(v, list):\r\n            GO.add_parameters(k, v)\r\n\r\n    GO.generate_setting_for_ga()\r\n\r\n    GO.generate_parameter()\r\n\r\n    GO.optimize()\r\n", "meta": {"hexsha": "95d90cda0667718059b9c8c7327478893bc45f25", "size": 9772, "ext": "py", "lang": "Python", "max_stars_repo_path": "vnpy/app/cta_strategy_pro/genetic_optimize.py", "max_stars_repo_name": "garywangiam02/vnpy", "max_stars_repo_head_hexsha": "fbb168bf977d95ae874e92a3655c6c893db16a1f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "vnpy/app/cta_strategy_pro/genetic_optimize.py", "max_issues_repo_name": "garywangiam02/vnpy", "max_issues_repo_head_hexsha": "fbb168bf977d95ae874e92a3655c6c893db16a1f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "vnpy/app/cta_strategy_pro/genetic_optimize.py", "max_forks_repo_name": "garywangiam02/vnpy", "max_forks_repo_head_hexsha": "fbb168bf977d95ae874e92a3655c6c893db16a1f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.9754601227, "max_line_length": 116, "alphanum_fraction": 0.5569995907, "include": true, "reason": "import numpy", "num_tokens": 2586, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4610167793123159, "lm_q2_score": 0.12421300024700382, "lm_q1q2_score": 0.0572642773225936}}
{"text": "from typing import Optional, Sequence, Union\n\nimport numpy as np\n\nfrom mygrad.tensor_base import Tensor, _resolve_constant, implements_numpy_override\nfrom mygrad.typing import ArrayLike, DTypeLikeReals, Real\n\nShape = Union[Sequence[int], int]\n\n\ndef _anything_but_tensor(x):\n    if isinstance(x, Tensor):\n        x = x.data\n    return x\n\n\n__all__ = [\n    \"arange\",\n    \"empty\",\n    \"empty_like\",\n    \"eye\",\n    \"geomspace\",\n    \"identity\",\n    \"linspace\",\n    \"logspace\",\n    \"ones\",\n    \"ones_like\",\n    \"full\",\n    \"full_like\",\n    \"zeros\",\n    \"zeros_like\",\n]\n\n\ndef empty(\n    shape: Shape, dtype: DTypeLikeReals = np.float32, *, constant: Optional[bool] = None\n) -> Tensor:\n    \"\"\"Return a new Tensor of the given shape and type, without initializing entries.\n\n    This docstring was adapted from ``numpy.empty`` [1]_\n\n    Parameters\n    ----------\n    shape : Union[int, Tuple[int]]\n        The shape of the empty array.\n\n    dtype : data-type, optional (default=numpy.float32)\n        The data type of the output Tensor.\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation.\n\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n        Integer-type tensors must be constant.\n\n    Returns\n    -------\n    Tensor\n        A tensor of uninitialized data of the given shape and dtype.\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.empty.html\n\n    See Also\n    --------\n    empty_like : Return an empty tensor with shape and type of input.\n    ones : Return a new tensor setting values to one.\n    zeros : Return a new tensor setting values to zero.\n    full : Return a new tensor of given shape filled with value.\n\n\n    Notes\n    -----\n    `empty`, unlike `zeros`, does not set the array values to zero,\n    and may therefore be marginally faster.  On the other hand, it requires\n    the user to manually set all the values in the array, and should be\n    used with caution.\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> mg.empty([2, 2], constant=True)\n    Tensor([[ -9.74499359e+001,   6.69583040e-309],\n            [  2.13182611e-314,   3.06959433e-309]])         #random\n\n    >>> mg.empty([2, 2], dtype=int)\n    Tensor([[-1073741821, -1067949133],\n            [  496041986,    19249760]])                     #random\n    \"\"\"\n    return Tensor(np.empty(shape=shape, dtype=dtype), constant=constant, copy=False)\n\n\n@implements_numpy_override()\ndef empty_like(\n    other: ArrayLike,\n    dtype: Optional[DTypeLikeReals] = None,\n    shape: Optional[Union[int, Sequence[int]]] = None,\n    *,\n    constant: Optional[bool] = None,\n) -> Tensor:\n    \"\"\"Return a new Tensor of the same shape and type as the given array.\n\n    This docstring was adapted from ``numpy.empty_like`` [1]_\n\n    Parameters\n    ----------\n    other : ArrayLike\n        The Tensor or array whose shape and datatype should be mirrored.\n\n    dtype : Optional[DTypeLikeReals]\n        Override the data type of the returned Tensor with this value, or None to not override.\n\n    shape : Optional[Union[int, Sequence[int]]]\n        If specified, overrides the shape of the result\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation. If ``None`` then:\n\n        Inferred from ``other``, if other is a tensor\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n    Returns\n    -------\n    Tensor\n        A tensor of uninitialized data whose shape and type match `other`.\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.empty_like.html\n\n    See Also\n    --------\n    empty : Return a new Tensor of the given shape and type, without initializing entries.\n    ones : Return a new tensor setting values to one.\n    zeros : Return a new tensor setting values to zero.\n    full : Return a new tensor of given shape filled with value.\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> x = mg.arange(4).reshape(2, 2)\n    >>> mg.empty_like(x, constant=True)\n    Tensor([[ -9.74499359e+001,   6.69583040e-309],\n            [  2.13182611e-314,   3.06959433e-309]])         #random\n\n    >>> mg.empty_like(x, dtype=int)\n    Tensor([[-1073741821, -1067949133],\n            [  496041986,    19249760]])                     #random\n    \"\"\"\n    constant = _resolve_constant(other, constant=constant)\n    return Tensor(\n        np.empty_like(_anything_but_tensor(other), dtype=dtype, shape=shape),\n        constant=constant,\n        copy=False,\n    )\n\n\ndef eye(\n    N: int,\n    M: Optional[int] = None,\n    k: int = 0,\n    dtype: DTypeLikeReals = float,\n    *,\n    constant: Optional[bool] = None,\n) -> Tensor:\n    \"\"\"Return a 2D Tensor with ones on the diagonal and zeros elsewhere.\n\n    This docstring was adapted from ``numpy.eye`` [1]_\n\n    Parameters\n    ----------\n    N : int\n        The number of rows in the output Tensor.\n\n    M : int, optional (default=None)\n        The number of columns in the output, or None to match `rows`.\n\n    k : int, optional (default=0)\n        The index of the diagonal. 0 is the main diagonal; a positive value is the upper\n        diagonal, while a negative value refers to the lower diagonal.\n\n    dtype : data-type, optional (default=numpy.float32)\n        The data type of the output Tensor.\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation.\n\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n        Integer-type tensors must be constant.\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.eye.html\n\n    Returns\n    -------\n    Tensor\n        A tensor whose elements are 0, except for the :math:`k`-th diagonal, whose values are 1.\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> mg.eye(2, dtype=int)\n    Tensor([[1, 0],\n            [0, 1]])\n    >>> mg.eye(3, k=1)\n    Tensor([[ 0.,  1.,  0.],\n            [ 0.,  0.,  1.],\n            [ 0.,  0.,  0.]])\n    \"\"\"\n    return Tensor(\n        np.eye(N, M=M, k=k, dtype=dtype),\n        constant=constant,\n        copy=False,\n    )\n\n\ndef identity(\n    n: int, dtype: DTypeLikeReals = float, *, constant: Optional[bool] = None\n) -> Tensor:\n    \"\"\"Return the identity Tensor; a square Tensor with 1s on the main diagonal and 0s elsewhere.\n\n    This docstring was adapted from ``numpy.identity`` [1]_\n\n    Parameters\n    ----------\n    n : int\n        The number of rows and columns in the output Tensor.\n\n    dtype : data-type, optional (default=numpy.float32)\n        The data type of the output Tensor.\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation.\n\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n        Integer-type tensors must be constant.\n\n    Returns\n    -------\n    Tensor\n        A square Tensor whose main diagonal is 1 and all other elements are 0.\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.identity.html\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> mg.identity(3)\n    Tensor([[ 1.,  0.,  0.],\n            [ 0.,  1.,  0.],\n            [ 0.,  0.,  1.]])\n    \"\"\"\n    return Tensor(np.identity(n, dtype=dtype), constant=constant, copy=False)\n\n\ndef ones(\n    shape: Shape, dtype: DTypeLikeReals = np.float32, *, constant: Optional[bool] = None\n) -> Tensor:\n    \"\"\"\n    Return a Tensor of the given shape and type, filled with ones.\n\n    This docstring was adapted from ``numpy.ones`` [1]_\n\n    Parameters\n    ----------\n    shape : Union[int, Tuple[int]]\n        The shape of the output Tensor.\n\n    dtype : data-type, optional (default=numpy.float32)\n        The data type of the output Tensor.\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation.\n\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n        Integer-type tensors must be constant.\n\n    Returns\n    -------\n    Tensor\n        A Tensor of ones with the given shape and data type.\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.ones.html\n\n    See Also\n    --------\n    ones_like : Return an tensor of ones with shape and type of input.\n    empty : Return a new uninitialized tensor.\n    zeros : Return a new tensor setting values to zero.\n    full : Return a new tensor of given shape filled with value.\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> mg.ones(5)\n    Tensor([ 1.,  1.,  1.,  1.,  1.])\n\n    >>> mg.ones((5,), dtype=int)\n    Tensor([1, 1, 1, 1, 1])\n\n    >>> mg.ones((2, 1))\n    Tensor([[ 1.],\n           [ 1.]])\n\n    >>> mg.ones((2, 2))\n    Tensor([[ 1.,  1.],\n            [ 1.,  1.]])\n    \"\"\"\n    return Tensor(np.ones(shape, dtype=dtype), constant=constant, copy=False)\n\n\n@implements_numpy_override()\ndef ones_like(\n    other: ArrayLike,\n    dtype: Optional[DTypeLikeReals] = None,\n    shape: Optional[Union[int, Sequence[int]]] = None,\n    *,\n    constant: Optional[bool] = None,\n) -> Tensor:\n    \"\"\"\n    Return a Tensor of the same shape and type as the given, filled with ones.\n\n    This docstring was adapted from ``numpy.ones_like`` [1]_\n\n    Parameters\n    ----------\n    other : array_like\n        The Tensor or array whose shape and datatype should be mirrored.\n\n    dtype : Optional[DTypeLikeReals]\n        Override the data type of the returned Tensor with this value, or None to not override.\n\n    shape : Optional[Union[int, Sequence[int]]]\n        If specified, overrides the shape of the result\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation. If ``None`` then:\n\n        Inferred from ``other``, if other is a tensor\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n\n    Returns\n    -------\n    Tensor\n        A Tensor of ones whose shape and data type match `other`.\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.ones_like.html\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> x = mg.arange(6).reshape((2, 3))\n    >>> x\n    Tensor([[0, 1, 2],\n            [3, 4, 5]])\n\n    >>> mg.ones_like(x)\n    Tensor([[1, 1, 1],\n            [1, 1, 1]])\n\n    >>> y = mg.arange(3, dtype=float)\n    >>> y\n    Tensor([ 0.,  1.,  2.])\n\n    >>> mg.ones_like(y)\n    Tensor([ 1.,  1.,  1.])\n    \"\"\"\n    constant = _resolve_constant(other, constant=constant)\n\n    return Tensor(\n        np.ones_like(_anything_but_tensor(other), dtype=dtype, shape=shape),\n        constant=constant,\n        copy=False,\n    )\n\n\ndef zeros(\n    shape: Shape, dtype: DTypeLikeReals = np.float32, *, constant: Optional[bool] = None\n) -> Tensor:\n    \"\"\"\n    Return a Tensor of the given shape and type, filled with zeros.\n\n    This docstring was adapted from ``numpy.zeros`` [1]_\n\n    Parameters\n    ----------\n    shape : Union[int, Tuple[int]]\n        The shape of the output Tensor.\n\n    dtype : data-type, optional (default=numpy.float32)\n        The data type of the output Tensor.\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation.\n\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n        Integer-type tensors must be constant.\n\n    Returns\n    -------\n    Tensor\n        A Tensor of zeros with the given shape and data type.\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.zeros.html\n\n    See Also\n    --------\n    ones_like : Return an tensor of ones with shape and type of input.\n    empty : Return a new uninitialized tensor.\n    ones : Return a new tensor setting values to one.\n    full : Return a new tensor of given shape filled with value.\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> mg.zeros(5)\n    Tensor([ 0.,  0.,  0.,  0.,  0.])\n\n    >>> mg.zeros((5,), dtype=int, constant=True) # tensor will not back-propagate a gradient\n    Tensor([0, 0, 0, 0, 0])\n\n    >>> mg.zeros((2, 1))\n    Tensor([[ 0.],\n            [ 0.]])\n\n    >>> mg.zeros((2, 2))\n    Tensor([[ 0.,  0.],\n            [ 0.,  0.]])\n    \"\"\"\n    return Tensor(np.zeros(shape, dtype), constant=constant, copy=False)\n\n\n@implements_numpy_override()\ndef zeros_like(\n    other: ArrayLike,\n    dtype: Optional[DTypeLikeReals] = None,\n    shape: Optional[Union[int, Shape]] = None,\n    *,\n    constant: Optional[bool] = None,\n) -> Tensor:\n    \"\"\"\n    Return a Tensor of the same shape and type as the given, filled with zeros.\n\n    This docstring was adapted from ``numpy.zeros_like`` [1]_\n\n    Parameters\n    ----------\n    other : ArrayLike\n        The Tensor or array whose shape and datatype should be mirrored.\n\n    dtype : Optional[DTypeLikeReals]\n        Override the data type of the returned Tensor with this value, or None to not override.\n\n    shape : Optional[int, Sequence[int]]\n        If specified, overrides the shape of the result\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation. If ``None`` then:\n\n        Inferred from ``other``, if other is a tensor\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n        Integer-type tensors must be constant.\n\n    Returns\n    -------\n    Tensor\n        A Tensor of zeros whose shape and data type match `other`.\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.zeros_like.html\n\n    See Also\n    --------\n    empty_like : Return an empty tensor with shape and type of input.\n    ones_like : Return an tensor of ones with shape and type of input.\n    full_like : Return a new tensor with shape of input filled with value.\n    zeros : Return a new tensor setting values to zero.\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> x = mg.arange(6).reshape((2, 3))\n    >>> x\n    Tensor([[0, 1, 2],\n            [3, 4, 5]])\n\n    >>> mg.zeros_like(x, constant=True)  # tensor will not back-propagate a gradient\n    Tensor([[0, 0, 0],\n            [0, 0, 0]])\n\n    >>> y = mg.arange(3, dtype=float)\n    >>> y\n    Tensor([ 0.,  1.,  2.])\n\n    >>> mg.zeros_like(y)\n    Tensor([ 0.,  0.,  0.])\n    \"\"\"\n    constant = _resolve_constant(other, constant=constant)\n    return Tensor(\n        np.zeros_like(_anything_but_tensor(other), dtype=dtype, shape=shape),\n        constant=constant,\n        copy=False,\n    )\n\n\ndef full(\n    shape: Shape,\n    fill_value: ArrayLike,\n    dtype: Optional[DTypeLikeReals] = None,\n    *,\n    constant: Optional[bool] = None,\n) -> Tensor:\n    \"\"\"\n    Return a Tensor of the given shape and type, filled with `fill_value`.\n\n    This docstring was adapted from ``numpy.full`` [1]_\n\n    Parameters\n    ----------\n    shape : Union[int, Iterable[int]]\n        The shape of the output Tensor.\n\n    fill_value : ArrayLike\n        The value with which to fill the output Tensor. Note that this function\n        is not differentiable – the resulting tensor will not backprop through\n        `fill_value`.\n\n        The value with which to fill the output Tensor.\n\n    dtype : Optional[DTypeLikeReals]\n        The data type of the output Tensor, or None to match `fill_value`..\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation.\n\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n        Integer-type tensors must be constant.\n\n    Returns\n    -------\n    Tensor\n        A Tensor of `fill_value` with the given shape and dtype.\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.full.html\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> mg.full((2, 2), 33)\n    Tensor([[ 33,  33],\n            [ 33,  33]])\n\n    >>> mg.full((2, 2), 10)\n    Tensor([[10, 10],\n            [10, 10]])\n    \"\"\"\n    return Tensor(\n        np.full(shape, fill_value=fill_value, dtype=dtype),\n        constant=constant,\n        copy=False,\n    )\n\n\n@implements_numpy_override()\ndef full_like(\n    other: ArrayLike,\n    fill_value: Real,\n    dtype: Optional[DTypeLikeReals] = None,\n    shape: Optional[Union[int, Shape]] = None,\n    constant: Optional[bool] = None,\n) -> Tensor:\n    \"\"\"Return a Tensor of the same shape and type as the given, filled with `fill_value`.\n\n    This docstring was adapted from ``numpy.full_like`` [1]_\n\n    Parameters\n    ----------\n    other : ArrayLike\n        The tensor or array whose shape and datatype should be mirrored.\n\n    fill_value : Real\n        The value with which to fill the output Tensor.\n\n    dtype : Optional[DTypeLikeReals]\n        Override the data type of the returned Tensor with this value, or None to not override.\n\n    shape : Optional[int, Sequence[int]]\n        If specified, overrides the shape of the result\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation. If ``None`` then:\n\n        Inferred from ``other``, if other is a tensor\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n    Returns\n    -------\n    Tensor\n        A Tensor of `fill_value` whose shape and data type match `other`.\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.full_like.html\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> x = mg.arange(6, dtype=int)\n    >>> mg.full_like(x, 1)\n    Tensor([1, 1, 1, 1, 1, 1])\n    >>> mg.full_like(x, 0.1)\n    Tensor([0, 0, 0, 0, 0, 0])\n    >>> mg.full_like(x, 0.1, dtype=np.double)\n    Tensor([ 0.1,  0.1,  0.1,  0.1,  0.1,  0.1])\n    >>> mg.full_like(x, np.nan, dtype=np.double)\n    Tensor([ nan,  nan,  nan,  nan,  nan,  nan])\n\n    >>> y = mg.arange(6, dtype=np.double)\n    >>> mg.full_like(y, 0.1)\n    Tensor([ 0.1,  0.1,  0.1,  0.1,  0.1,  0.1])\n    \"\"\"\n    constant = _resolve_constant(other, constant=constant)\n\n    return Tensor(\n        np.full_like(\n            _anything_but_tensor(other),\n            fill_value=_anything_but_tensor(fill_value),\n            dtype=dtype,\n            shape=shape,\n        ),\n        constant=constant,\n        copy=False,\n    )\n\n\ndef arange(\n    *args,\n    constant: Optional[bool] = None,\n    **kwargs,\n) -> Tensor:\n    \"\"\"\n    arange([start,] stop[, step,], dtype=None, *, constant=None)\n\n    Return a Tensor with evenly-spaced values within a given interval.\n\n    Values are generated within [start, stop). Note that for non-integer steps, results may be\n    inconsistent; you are better off using `linspace` instead.\n\n    This docstring was adapted from ``numpy.arange`` [1]_\n\n    Parameters\n    ----------\n    start : Real, optional, default=0\n        The start of the interval, inclusive.\n\n    stop : Real\n        The end of the interval, exclusive.\n\n    step : int, optional (default=1)\n        The spacing between successive values.\n\n    dtype : Optional[DTypeLikeReals]\n        The data type of the output Tensor, or None to infer from the inputs.\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation.\n\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n        Integer-type tensors must be constant.\n\n    Returns\n    -------\n    Tensor\n        A Tensor of evenly-spaced values in [start, end).\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.arange.html\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> mg.arange(3)\n    Tensor([0, 1, 2])\n    >>> mg.arange(3.0, constant=True)  # resulting tensor will not back-propagate a gradient\n    Tensor([ 0.,  1.,  2.])\n    >>> mg.arange(3,7)\n    Tensor([3, 4, 5, 6])\n    >>> mg.arange(3,7,2)\n    Tensor([3, 5])\n    \"\"\"\n    return Tensor(np.arange(*args, **kwargs), constant=constant, copy=False)\n\n\ndef linspace(\n    start: ArrayLike,\n    stop: ArrayLike,\n    num: int = 50,\n    endpoint: bool = True,\n    dtype: Optional[DTypeLikeReals] = None,\n    axis: int = 0,\n    *,\n    constant: Optional[bool] = None,\n) -> Tensor:\n    \"\"\"Return a Tensor with evenly-spaced numbers over a specified interval.\n\n    Values are generated within [start, stop], with the endpoint optionally excluded.\n\n    This docstring was adapted from ``numpy.linspace`` [1]_\n\n    Parameters\n    ----------\n    start : ArrayLike\n        The starting value of the sequence, inclusive.\n\n    stop : ArrayLike\n        The ending value of the sequence, inclusive unless `include_endpoint` is False.\n\n    num : int, optional (default=50)\n        The number of values to generate. Must be non-negative.\n\n    endpoint : bool, optional (default=True)\n        Whether to include the endpoint in the Tensor. Note that if False, the step size changes\n        to accommodate the sequence excluding the endpoint.\n\n    dtype : Optional[DTypeLikeReals]\n        The data type of the output Tensor, or None to infer from the inputs.\n\n    axis : int, optional (default=0)\n        The axis in the result to store the samples - for array-like start/stop.\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation.\n\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n        Integer-type tensors must be constant.\n\n    Returns\n    -------\n    Tensor\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.linspace.html\n\n    See Also\n    --------\n    arange : Similar to `linspace`, but uses a step size (instead of the\n             number of samples).\n    logspace : Samples uniformly distributed in log space.\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> mg.linspace(2.0, 3.0, num=5)\n    Tensor([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ])\n    >>> mg.linspace(2.0, 3.0, num=5, endpoint=False)\n    Tensor([ 2. ,  2.2,  2.4,  2.6,  2.8])\n    \"\"\"\n    return Tensor(\n        np.linspace(\n            start,\n            stop,\n            num,\n            endpoint=endpoint,\n            dtype=dtype,\n            axis=axis,\n        ),\n        constant=constant,\n        copy=False,\n    )\n\n\ndef logspace(\n    start: ArrayLike,\n    stop: ArrayLike,\n    num: int = 50,\n    endpoint: bool = True,\n    base: Real = 10,\n    dtype: Optional[DTypeLikeReals] = None,\n    axis: int = 0,\n    *,\n    constant: Optional[bool] = None,\n) -> Tensor:\n    \"\"\"Return a Tensor with evenly-spaced numbers over a specified interval on a log scale.\n    This is not a differentiable function - it does not propagate gradients to its inputs.\n\n    In linear space, values are generated within [base**start, base**stop], with the endpoint\n    optionally excluded.\n\n    This docstring was adapted from ``numpy.logspace`` [1]_\n\n    Parameters\n    ----------\n    start : ArrayLike\n        The starting value of the sequence, inclusive; start at `base ** start`.\n\n    stop : ArrayLike\n        The ending value of the sequence, inclusive unless `include_endpoint` is False; end at\n        `base ** stop`.\n\n    num : int, optional (default=50)\n        The number of values to generate. Must be non-negative.\n\n    endpoint : bool, optional (default=True)\n        Whether to include the endpoint in the Tensor. Note that if False, the step size changes\n        to accommodate the sequence excluding the endpoint.\n\n    base : Real, optional (default=10)\n        The base of the log space.\n\n    dtype : Optional[DTypeLikeReals]\n        The data type of the output Tensor, or None to infer from the inputs.\n\n    axis : int, optional (default=0)\n        The axis in the result to store the samples - for array-like start/stop.\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation.\n\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n        Integer-type tensors must be constant.\n\n    Returns\n    -------\n    Tensor\n\n    See Also\n    --------\n    arange : Similar to linspace, with the step size specified instead of the\n             number of samples. Note that, when used with a float endpoint, the\n             endpoint may or may not be included.\n    linspace : Similar to logspace, but with the samples uniformly distributed\n               in linear space, instead of log space.\n    geomspace : Similar to logspace, but with endpoints specified directly.\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.logspace.html\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> mg.logspace(2.0, 3.0, num=4)\n    Tensor([  100.        ,   215.443469  ,   464.15888336,  1000.        ])\n    >>> mg.logspace(2.0, 3.0, num=4, endpoint=False)\n    Tensor([ 100.        ,  177.827941  ,  316.22776602,  562.34132519])\n    >>> mg.logspace(2.0, 3.0, num=4, base=2.0)\n    Tensor([ 4.        ,  5.0396842 ,  6.34960421,  8.        ])\n\n    \"\"\"\n    return Tensor(\n        np.logspace(\n            start=start,\n            stop=stop,\n            num=num,\n            endpoint=endpoint,\n            base=base,\n            dtype=dtype,\n            axis=axis,\n        ),\n        constant=constant,\n        copy=False,\n    )\n\n\ndef geomspace(\n    start: ArrayLike,\n    stop: ArrayLike,\n    num=50,\n    endpoint=True,\n    dtype=None,\n    axis=0,\n    *,\n    constant: Optional[bool] = None,\n) -> Tensor:\n    \"\"\"Return a Tensor with evenly-spaced values in a geometric progression.\n\n    Each output sample is a constant multiple of the previous output.\n\n    This docstring was adapted from ``numpy.geomspace`` [1]_\n\n    Parameters\n    ----------\n    start : ArrayLike\n        The starting value of the output.\n\n    stop : ArrayLike\n        The ending value of the sequence, inclusive unless `endpoint` is false.\n\n    num : int, optional (default=50)\n        The number of values to generate. Must be non-negative.\n\n    endpoint : bool, optional (default=True)\n        Whether to include the endpoint in the Tensor. Note that if False, the step size changes\n        to accommodate the sequence excluding the endpoint.\n\n    dtype : Optional[DTypeLikeReals]\n        The data type of the output Tensor, or None to infer from the inputs.\n\n    axis : int, optional (default=0)\n        The axis in the result to store the samples - for array-like start/stop.\n\n    constant : Optional[bool]\n        If ``True``, this tensor is a constant, and thus does not facilitate\n        back propagation.\n\n        Defaults to ``False`` for float-type data.\n        Defaults to ``True`` for integer-type data.\n\n        Integer-type tensors must be constant.\n\n    Returns\n    -------\n    Tensor\n\n    References\n    ----------\n    .. [1] Retrieved from https://numpy.org/doc/stable/reference/generated/numpy.geomspace.html\n\n    See Also\n    --------\n    logspace : Similar to geomspace, but with endpoints specified using log\n               and base.\n    linspace : Similar to geomspace, but with arithmetic instead of geometric\n               progression.\n    arange : Similar to linspace, with the step size specified instead of the\n             number of samples.\n\n    Examples\n    --------\n    >>> import mygrad as mg\n    >>> mg.geomspace(1, 1000, num=4)\n    Tensor([    1.,    10.,   100.,  1000.])\n    >>> mg.geomspace(1, 1000, num=3, endpoint=False)\n    Tensor([   1.,   10.,  100.])\n    >>> mg.geomspace(1, 1000, num=4, endpoint=False)\n    Tensor([   1.        ,    5.62341325,   31.6227766 ,  177.827941  ])\n    >>> mg.geomspace(1, 256, num=9)\n    Tensor([   1.,    2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.])\n\n    Note that the above may not produce exact integers:\n\n    >>> mg.geomspace(1, 256, num=9, dtype=int)\n    Tensor([  1,   2,   4,   7,  16,  32,  63, 127, 256])\n    >>> np.around(mg.geomspace(1, 256, num=9).data).astype(int)\n    array([  1,   2,   4,   8,  16,  32,  64, 128, 256])\n\n    Negative, and decreasing inputs are allowed:\n\n    >>> mg.geomspace(1000, 1, num=4)\n    Tensor([ 1000.,   100.,    10.,     1.])\n    >>> mg.geomspace(-1000, -1, num=4)\n    Tensor([-1000.,  -100.,   -10.,    -1.])\n    \"\"\"\n    return Tensor(\n        np.geomspace(\n            start=start,\n            stop=stop,\n            num=num,\n            endpoint=endpoint,\n            dtype=dtype,\n            axis=axis,\n        ),\n        constant=constant,\n        copy=False,\n    )\n", "meta": {"hexsha": "59076921f2e9f26be7869ba75959b63cb0f31cae", "size": 29185, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/mygrad/tensor_creation/funcs.py", "max_stars_repo_name": "kw-0/MyGrad", "max_stars_repo_head_hexsha": "307f1bb5f2391e7f4df49fe43a7acf9d1e8ea141", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 147, "max_stars_repo_stars_event_min_datetime": "2018-07-14T01:37:35.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T06:37:58.000Z", "max_issues_repo_path": "src/mygrad/tensor_creation/funcs.py", "max_issues_repo_name": "kw-0/MyGrad", "max_issues_repo_head_hexsha": "307f1bb5f2391e7f4df49fe43a7acf9d1e8ea141", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 223, "max_issues_repo_issues_event_min_datetime": "2018-05-31T14:13:18.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-27T18:53:49.000Z", "max_forks_repo_path": "src/mygrad/tensor_creation/funcs.py", "max_forks_repo_name": "kw-0/MyGrad", "max_forks_repo_head_hexsha": "307f1bb5f2391e7f4df49fe43a7acf9d1e8ea141", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 27, "max_forks_repo_forks_event_min_datetime": "2018-06-17T14:42:05.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-31T00:21:09.000Z", "avg_line_length": 28.6689587426, "max_line_length": 97, "alphanum_fraction": 0.6001370567, "include": true, "reason": "import numpy", "num_tokens": 7436, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.11436853372838406, "lm_q1q2_score": 0.05718426686419203}}
{"text": "\"\"\" Tools for doing common subexpression elimination.\n\"\"\"\nfrom __future__ import print_function, division\n\nimport difflib\n\nfrom sympy.core import Basic, Mul, Add, sympify\nfrom sympy.core.basic import preorder_traversal\nfrom sympy.core.function import _coeff_isneg\nfrom sympy.core.compatibility import iterable, xrange\nfrom sympy.utilities.iterables import numbered_symbols, \\\n    sift, topological_sort, ordered\n\nfrom . import cse_opts\n\n# (preprocessor, postprocessor) pairs which are commonly useful. They should\n# each take a sympy expression and return a possibly transformed expression.\n# When used in the function ``cse()``, the target expressions will be transformed\n# by each of the preprocessor functions in order. After the common\n# subexpressions are eliminated, each resulting expression will have the\n# postprocessor functions transform them in *reverse* order in order to undo the\n# transformation if necessary. This allows the algorithm to operate on\n# a representation of the expressions that allows for more optimization\n# opportunities.\n# ``None`` can be used to specify no transformation for either the preprocessor or\n# postprocessor.\n\ncse_optimizations = list(cse_opts.default_optimizations)\n\n# sometimes we want the output in a different format; non-trivial\n# transformations can be put here for users\n# ===============================================================\n\n\ndef reps_toposort(r):\n    \"\"\"Sort replacements `r` so (k1, v1) appears before (k2, v2)\n    if k2 is in v1's free symbols. This orders items in the\n    way that cse returns its results (hence, in order to use the\n    replacements in a substitution option it would make sense\n    to reverse the order).\n\n    Examples\n    ========\n    >>> from sympy.simplify.cse_main import reps_toposort\n    >>> from sympy.abc import x, y\n    >>> from sympy import Eq\n    >>> for l, r in reps_toposort([(x, y + 1), (y, 2)]):\n    ...     print(Eq(l, r))\n    ...\n    y == 2\n    x == y + 1\n\n    \"\"\"\n    r = sympify(r)\n    E = []\n    for c1, (k1, v1) in enumerate(r):\n        for c2, (k2, v2) in enumerate(r):\n            if k1 in v2.free_symbols:\n                E.append((c1, c2))\n    return [r[i] for i in topological_sort((range(len(r)), E))]\n\n\ndef cse_separate(r, e):\n    \"\"\"Move expressions that are in the form (symbol, expr) out of the\n    expressions and sort them into the replacements using the reps_toposort.\n\n    Examples\n    ========\n    >>> from sympy.simplify.cse_main import cse_separate\n    >>> from sympy.abc import x, y, z\n    >>> from sympy import cos, exp, cse, Eq, symbols\n    >>> x0, x1 = symbols('x:2')\n    >>> eq = (x + 1 + exp((x + 1)/(y + 1)) + cos(y + 1))\n    >>> cse([eq, Eq(x, z + 1), z - 2], postprocess=cse_separate) in [\n    ... [[(x0, y + 1), (x, z + 1), (x1, x + 1)],\n    ...  [x1 + exp(x1/x0) + cos(x0), z - 2]],\n    ... [[(x1, y + 1), (x, z + 1), (x0, x + 1)],\n    ...  [x0 + exp(x0/x1) + cos(x1), z - 2]]]\n    ...\n    True\n    \"\"\"\n    d = sift(e, lambda w: w.is_Equality and w.lhs.is_Symbol)\n    r = r + [w.args for w in d[True]]\n    e = d[False]\n    return [reps_toposort(r), e]\n\n# ====end of cse postprocess idioms===========================\n\n\ndef preprocess_for_cse(expr, optimizations):\n    \"\"\" Preprocess an expression to optimize for common subexpression\n    elimination.\n\n    Parameters\n    ----------\n    expr : sympy expression\n        The target expression to optimize.\n    optimizations : list of (callable, callable) pairs\n        The (preprocessor, postprocessor) pairs.\n\n    Returns\n    -------\n    expr : sympy expression\n        The transformed expression.\n    \"\"\"\n    for pre, post in optimizations:\n        if pre is not None:\n            expr = pre(expr)\n    return expr\n\n\ndef postprocess_for_cse(expr, optimizations):\n    \"\"\" Postprocess an expression after common subexpression elimination to\n    return the expression to canonical sympy form.\n\n    Parameters\n    ----------\n    expr : sympy expression\n        The target expression to transform.\n    optimizations : list of (callable, callable) pairs, optional\n        The (preprocessor, postprocessor) pairs.  The postprocessors will be\n        applied in reversed order to undo the effects of the preprocessors\n        correctly.\n\n    Returns\n    -------\n    expr : sympy expression\n        The transformed expression.\n    \"\"\"\n    if optimizations is None:\n        optimizations = cse_optimizations\n    for pre, post in reversed(optimizations):\n        if post is not None:\n            expr = post(expr)\n    return expr\n\n\ndef _remove_singletons(reps, exprs):\n    \"\"\"\n    Helper function for cse that will remove expressions that weren't\n    used more than once.\n    \"\"\"\n    u_reps = []  # the useful reps that are used more than once\n    for i, ui in enumerate(reps):\n        used = []  # where it was used\n        ri, ei = ui\n\n        # keep track of whether the substitution was used more\n        # than once. If used is None, it was never used (yet);\n        # if used is an int, that is the last place where it was\n        # used (>=0 in the reps, <0 in the expressions) and if\n        # it is True, it was used more than once.\n\n        used = None\n\n        tot = 0  # total times used so far\n\n        # search through the reps\n        for j in range(i + 1, len(reps)):\n            c = reps[j][1].count(ri)\n            if c:\n                tot += c\n                if tot > 1:\n                    u_reps.append(ui)\n                    used = True\n                    break\n                else:\n                    used = j\n\n        if used is not True:\n\n            # then search through the expressions\n\n            for j, rj in enumerate(exprs):\n                c = rj.count(ri)\n                if c:\n                    # append a negative so we know that it was in the\n                    # expression that used it\n                    tot += c\n                    if tot > 1:\n                        u_reps.append(ui)\n                        used = True\n                        break\n                    else:\n                        used = j - len(exprs)\n\n            if type(used) is int:\n\n                # undo the change\n\n                rep = {ri: ei}\n                j = used\n                if j < 0:\n                    exprs[j] = exprs[j].subs(rep)\n                else:\n                    reps[j] = reps[j][0], reps[j][1].subs(rep)\n\n    # reuse unused symbols so a contiguous range of symbols is returned\n\n    if len(u_reps) != len(reps):\n        for i, ri in enumerate(u_reps):\n            if u_reps[i][0] != reps[i][0]:\n                rep = (u_reps[i][0], reps[i][0])\n                u_reps[i] = rep[1], u_reps[i][1].subs(*rep)\n                for j in range(i + 1, len(u_reps)):\n                    u_reps[j] = u_reps[j][0], u_reps[j][1].subs(*rep)\n                for j, rj in enumerate(exprs):\n                    exprs[j] = exprs[j].subs(*rep)\n\n    reps[:] = u_reps  # change happens in-place\n\n\ndef cse(exprs, symbols=None, optimizations=None, postprocess=None):\n    \"\"\" Perform common subexpression elimination on an expression.\n\n    Parameters\n    ==========\n\n    exprs : list of sympy expressions, or a single sympy expression\n        The expressions to reduce.\n    symbols : infinite iterator yielding unique Symbols\n        The symbols used to label the common subexpressions which are pulled\n        out. The ``numbered_symbols`` generator is useful. The default is a\n        stream of symbols of the form \"x0\", \"x1\", etc. This must be an infinite\n        iterator.\n    optimizations : list of (callable, callable) pairs, optional\n        The (preprocessor, postprocessor) pairs. If not provided,\n        ``sympy.simplify.cse.cse_optimizations`` is used.\n    postprocess : a function which accepts the two return values of cse and\n        returns the desired form of output from cse, e.g. if you want the\n        replacements reversed the function might be the following lambda:\n        lambda r, e: return reversed(r), e\n\n    Returns\n    =======\n\n    replacements : list of (Symbol, expression) pairs\n        All of the common subexpressions that were replaced. Subexpressions\n        earlier in this list might show up in subexpressions later in this list.\n    reduced_exprs : list of sympy expressions\n        The reduced expressions with all of the replacements above.\n    \"\"\"\n    from sympy.matrices import Matrix\n\n    if symbols is None:\n        symbols = numbered_symbols()\n    else:\n        # In case we get passed an iterable with an __iter__ method instead of\n        # an actual iterator.\n        symbols = iter(symbols)\n    seen_subexp = set()\n    muls = set()\n    adds = set()\n    to_eliminate = set()\n\n    if optimizations is None:\n        # Pull out the default here just in case there are some weird\n        # manipulations of the module-level list in some other thread.\n        optimizations = list(cse_optimizations)\n\n    # Handle the case if just one expression was passed.\n    if isinstance(exprs, Basic):\n        exprs = [exprs]\n\n    # Preprocess the expressions to give us better optimization opportunities.\n    reduced_exprs = [preprocess_for_cse(e, optimizations) for e in exprs]\n\n    # Find all of the repeated subexpressions.\n    for expr in reduced_exprs:\n        if not isinstance(expr, Basic):\n            continue\n        pt = preorder_traversal(expr)\n        for subtree in pt:\n\n            inv = 1/subtree if subtree.is_Pow else None\n\n            if subtree.is_Atom or iterable(subtree) or inv and inv.is_Atom:\n                # Exclude atoms, since there is no point in renaming them.\n                continue\n\n            if subtree in seen_subexp:\n                if inv and _coeff_isneg(subtree.exp):\n                    # save the form with positive exponent\n                    subtree = inv\n                to_eliminate.add(subtree)\n                pt.skip()\n                continue\n\n            if inv and inv in seen_subexp:\n                if _coeff_isneg(subtree.exp):\n                    # save the form with positive exponent\n                    subtree = inv\n                to_eliminate.add(subtree)\n                pt.skip()\n                continue\n            elif subtree.is_Mul:\n                muls.add(subtree)\n            elif subtree.is_Add:\n                adds.add(subtree)\n\n            seen_subexp.add(subtree)\n\n    # process adds - any adds that weren't repeated might contain\n    # subpatterns that are repeated, e.g. x+y+z and x+y have x+y in common\n    adds = [set(a.args) for a in ordered(adds)]\n    for i in xrange(len(adds)):\n        for j in xrange(i + 1, len(adds)):\n            com = adds[i].intersection(adds[j])\n            if len(com) > 1:\n                to_eliminate.add(Add(*com))\n\n                # remove this set of symbols so it doesn't appear again\n                adds[i] = adds[i].difference(com)\n                adds[j] = adds[j].difference(com)\n                for k in xrange(j + 1, len(adds)):\n                    if not com.difference(adds[k]):\n                        adds[k] = adds[k].difference(com)\n\n    # process muls - any muls that weren't repeated might contain\n    # subpatterns that are repeated, e.g. x*y*z and x*y have x*y in common\n\n    # use SequenceMatcher on the nc part to find the longest common expression\n    # in common between the two nc parts\n    sm = difflib.SequenceMatcher()\n\n    muls = [a.args_cnc(cset=True) for a in ordered(muls)]\n    for i in xrange(len(muls)):\n        if muls[i][1]:\n            sm.set_seq1(muls[i][1])\n        for j in xrange(i + 1, len(muls)):\n            # the commutative part in common\n            ccom = muls[i][0].intersection(muls[j][0])\n\n            # the non-commutative part in common\n            if muls[i][1] and muls[j][1]:\n                # see if there is any chance of an nc match\n                ncom = set(muls[i][1]).intersection(set(muls[j][1]))\n                if len(ccom) + len(ncom) < 2:\n                    continue\n\n                # now work harder to find the match\n                sm.set_seq2(muls[j][1])\n                i1, _, n = sm.find_longest_match(0, len(muls[i][1]),\n                                                 0, len(muls[j][1]))\n                ncom = muls[i][1][i1:i1 + n]\n            else:\n                ncom = []\n\n            com = list(ccom) + ncom\n            if len(com) < 2:\n                continue\n\n            to_eliminate.add(Mul(*com))\n\n            # remove ccom from all if there was no ncom; to update the nc part\n            # would require finding the subexpr and then replacing it with a\n            # dummy to keep bounding nc symbols from being identified as a\n            # subexpr, e.g. removing B*C from A*B*C*D might allow A*D to be\n            # identified as a subexpr which would not be right.\n            if not ncom:\n                muls[i][0] = muls[i][0].difference(ccom)\n                for k in xrange(j, len(muls)):\n                    if not ccom.difference(muls[k][0]):\n                        muls[k][0] = muls[k][0].difference(ccom)\n\n    # make to_eliminate canonical; we will prefer non-Muls to Muls\n    # so select them first (non-Muls will have False for is_Mul and will\n    # be first in the ordering.\n    to_eliminate = list(ordered(to_eliminate, lambda _: _.is_Mul))\n\n    # Substitute symbols for all of the repeated subexpressions.\n    replacements = []\n    reduced_exprs = list(reduced_exprs)\n    hit = True\n    for i, subtree in enumerate(to_eliminate):\n        if hit:\n            sym = next(symbols)\n        hit = False\n        if subtree.is_Pow and subtree.exp.is_Rational:\n            update = lambda x: x.xreplace({subtree: sym, 1/subtree: 1/sym})\n        else:\n            update = lambda x: x.subs(subtree, sym)\n        # Make the substitution in all of the target expressions.\n        for j, expr in enumerate(reduced_exprs):\n            old = reduced_exprs[j]\n            reduced_exprs[j] = update(expr)\n            hit = hit or (old != reduced_exprs[j])\n        # Make the substitution in all of the subsequent substitutions.\n        for j in range(i + 1, len(to_eliminate)):\n            old = to_eliminate[j]\n            to_eliminate[j] = update(to_eliminate[j])\n            hit = hit or (old != to_eliminate[j])\n        if hit:\n            replacements.append((sym, subtree))\n\n    # Postprocess the expressions to return the expressions to canonical form.\n    for i, (sym, subtree) in enumerate(replacements):\n        subtree = postprocess_for_cse(subtree, optimizations)\n        replacements[i] = (sym, subtree)\n    reduced_exprs = [postprocess_for_cse(e, optimizations)\n        for e in reduced_exprs]\n\n    # remove replacements that weren't used more than once\n    _remove_singletons(replacements, reduced_exprs)\n\n    if isinstance(exprs, Matrix):\n        reduced_exprs = [Matrix(exprs.rows, exprs.cols, reduced_exprs)]\n    if postprocess is None:\n        return replacements, reduced_exprs\n    return postprocess(replacements, reduced_exprs)\n", "meta": {"hexsha": "81a7c377e244ffde56264355b8c092d514c85374", "size": 14903, "ext": "py", "lang": "Python", "max_stars_repo_path": "sympy/simplify/cse_main.py", "max_stars_repo_name": "torsknod/sympy-torsknod", "max_stars_repo_head_hexsha": "19425c8d2d876710413987eaa6e69ff9d47a0380", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-03-12T02:52:16.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-12T02:52:16.000Z", "max_issues_repo_path": "sympy/simplify/cse_main.py", "max_issues_repo_name": "torsknod/sympy-torsknod", "max_issues_repo_head_hexsha": "19425c8d2d876710413987eaa6e69ff9d47a0380", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sympy/simplify/cse_main.py", "max_forks_repo_name": "torsknod/sympy-torsknod", "max_forks_repo_head_hexsha": "19425c8d2d876710413987eaa6e69ff9d47a0380", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.2603406326, "max_line_length": 82, "alphanum_fraction": 0.5848486882, "include": true, "reason": "from sympy", "num_tokens": 3612, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4726834617637482, "lm_q2_score": 0.12085323565689977, "lm_q1q2_score": 0.05712532579565344}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     formats: ipynb,py\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.5'\n#       jupytext_version: 1.11.1\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# ## Cleaning scraped game data\n#\n# Here we show how to use the data obtained with Scrapy. In order to use it for data analysis and game outcome predictions, we first need to clean the data. \n#\n# Let's start with importing the packages we'll use:\n\nimport pandas as pd # Dataframes\nimport numpy as np # number crunching, matrices and all that\n\n# Let's now import the scraped data and perform a first simple cleaning step:\n# 1. We import the `.csv` file to a pandas data frame.\n# 2. There are games that were scraped multiple times because multiple of the selected top players were involved in them (a game might pop up in our data up to 10 times because of this). As these duplicates would skew the statistics, we remove them via `drop_duplicates`, using the starting time (`timestamp`) and the duration (`duration`) as unique identifiers.\n# 3. We reset the index of the data frame, which can be done explicitly (see commented line) or implicitly when removing duplicates via `ignore_index=True`.\n\ndf = pd.read_csv('../data/raw/games.csv')\ndf.drop_duplicates(subset=['duration', 'timestamp', 'team_1', 'team_2', 'winner'], inplace=True, keep='first', ignore_index=True)\n# df.reset_index(drop=True, inplace=True)\nprint(len(df))\ndf.head()\n\n# As we can see in the print-out of the data frame head above, we now have unique games in `df`, with the columns `duration`, `server`, `summoner_name`, `team_1`, `team_2`, `timestamp` and `winner`. We will usually discard the server, player (summoner) and time information in our analysis.\n#\n# In order to capture the roles of the played champions, which currently is implicitly stored in their order in `team_1` and `team_2`, we create 10 new columns - 5 for the red and blue team each - and store the champions individually:\n\n# These are the roles, in the same order as they are stored in team_1 and team_2.\nroles = ['Top', 'Jng', 'Mid', 'Adc', 'Sup']\n# For both teams...\nfor team_color, team_attr in zip(['B', 'R'], ['team_1', 'team_2']):\n    # ...decompose the column in a data frame of champion names...\n    team = df[team_attr].str.split(',', expand=True)\n    # ...and for all 5 roles, store the role column in the corresponding column of df.\n    for i, role in enumerate(roles):\n        df[f\"{team_color}{role}\"] = team[i]\ndf.drop(columns=['team_1', 'team_2'], inplace=True)\n\n# _Note on performance_: The above splitting of `team_1` and `team_2` is done for the entire data frame \"at once\" as we are using an internal pandas function (`pd.Series.str.split`) and then assign the full columns to the new role columns `BTop`, `BJng`... of `df`.\n#\n# Let's now rewrite the `winner` column to use `'Blue'` and `'Red'` instead of `'Team 1'` and `'Team 2'`, and drop the above mentioned columns of information we do not take into account.\n#\n# We also already can do a first step of data analysis and consider some stats:\n\ndf['winner'] = df.apply(lambda x: 'Blue' if x.winner=='Team 1' else 'Red', axis=1)\ndf.drop(['server', 'summoner_name', 'duration', 'timestamp'],axis=1,inplace=True)\n# Some statistics:\nnum_games = len(df)   # Total number of games\nnum_blue_wins = len(df[df['winner']=='Blue'])     # No of games blue won\nnum_red_wins = len(df[df['winner']=='Red'])      # No of games red won\nassert num_red_wins + num_blue_wins == num_games # Make sure we do not have a bad row without winner or such.\nblue_winrate = num_blue_wins/num_games\nred_winrate = num_red_wins/num_games\nprint(f\"There are {num_games} games recorded, the blue team won {num_blue_wins},\",\n      f\"the red team won {num_red_wins} of these games.\",\n      f\"\\nThis yields win rates of {blue_winrate*100:.2f}% (blue) and {red_winrate*100:.2f}% (red).\")\n\n# ### Looking at the champion stats\n# Now we will prepare a second important data frame using the data above: The statistics per champion.\n# To get the unique champion names, let's use `np.unique` on all role columns in `df`.\n\nBlue = [f'B{role}' for role in roles]\nRed = [f'R{role}' for role in roles]\nchampions = np.unique(df[Blue+Red])\n# cd = pd.DataFrame(champions, columns=['Champion'])\n\n# Now we compute the statistics per champion.\n#\n# In order to speed up the process by using `dict` lookups (which are very fast), we will not do the following steps in the `cd` data frame directly but make use of four separate dictionaries that capture the numbers of games/wins on the blue/red side for each champion. We also memorize the roles that the champions were played in, using a `dict` with `dict`s as values.\n#\n# To actually count the values we are interested in, we iterate over the data frame of games `df` _once_. For each row, we iterate over the roles and add to the counters in `blue_played` and `red_played` for the champions played on the respective side. We also memorize the role that each champion was played in. In order to count the wins on either side, we make use of python's automatic type casting and add the boolean `winner_is_blue`/`winner_is_red` to the counters in `blue_won` and `red_won`.\n\n# +\nblue_played = {champ: 0 for champ in champions}\nblue_won = {champ: 0 for champ in champions}\nred_played = {champ: 0 for champ in champions}\nred_won = {champ: 0 for champ in champions}\nroles_played = {champ: {role: 0 for role in roles} for champ in champions}\n\nfor _, row in df.iterrows():\n    winner_is_blue = row.winner=='Blue'\n    winner_is_red = not winner_is_blue\n    for blue_role in Blue:\n        champ = row[blue_role]\n        blue_played[champ] += 1\n        blue_won[champ] += winner_is_blue\n        # Strip the \"B\"/\"R\" from blue_role to get the role\n        roles_played[champ][blue_role[1:]] += 1\n    for red_role in Red:\n        champ = row[red_role]\n        red_played[champ] += 1\n        red_won[champ] += winner_is_red\n        roles_played[champ][red_role[1:]] += 1\n# -\n\n# Before storing everything in a data frame, let's figure out which were the most played roles per champion. For this, we iterate over the champions and sort the roles by their occurences for each champion. The `number_of_roles_to_record` most played roles and their counters are then stored in individual lists and linked to keys, for example `\"Role1\"` and `\"#Role1\"`, in a dictionary:\n\n# +\nnumber_of_roles_to_record = 2 # We use 2 roles, could use up to all 5\nordered_roles_played = [[] for _ in range(number_of_roles_to_record)]\nnumbers_roles_played = [[] for _ in range(number_of_roles_to_record)]\nfor i, champ in enumerate(champions):\n    # This is a list of tuples (role, #plays in the role):\n    roles_for_this_champ = list(roles_played[champ].items()) \n    # sort by number of plays, in descending order (reverse=True)\n    sorted_roles_for_this_champ = sorted(roles_for_this_champ, key=lambda x: x[1], reverse=True)\n    \n    # Now let's record the sorted tuples as order of most played roles (and their # of plays) \n    for j in range(number_of_roles_to_record):\n        ordered_roles_played[j].append(sorted_roles_for_this_champ[j][0]) # Record the role\n        numbers_roles_played[j].append(sorted_roles_for_this_champ[j][1]) # Record the # of plays\n        \nmost_played_roles = {f\"Role{j+1}\": ordered_roles_played[j] for j in range(number_of_roles_to_record)}\nmost_played_numbers = {f\"#Role{j+1}\": numbers_roles_played[j] for j in range(number_of_roles_to_record)}\n# -\n\n# Having all statistics sorted out, we can wrap everything up in a data frame. Because of the way we stored the most played roles above, we have a flexible pipeline that will generate the data frame for any number of most-played roles we want to store per champion.\n\ncd = pd.DataFrame({\n    'Champion': champions,\n    'BluePlayed': [blue_played[champ] for champ in champions],\n    'BlueWon': [blue_won[champ] for champ in champions],\n    'RedPlayed': [red_played[champ] for champ in champions],\n    'RedWon': [red_won[champ] for champ in champions],\n    **most_played_roles,\n    **most_played_numbers,\n})\n\n# We conclude the first round of data analysis by computing the total number of games played and the win rate on either side as well as in total, for each champion. For this, the column-wise operations on a data frame are very handy:\n\ncd['TotalPlayed'] = cd['BluePlayed'] + cd['RedPlayed']\ncd['Bluewinrate'] = cd['BlueWon'] / cd['BluePlayed']\ncd['Redwinrate'] = cd['RedWon'] / cd['RedPlayed']\ncd['Totalwinrate'] = (cd['BlueWon'] + cd['RedWon']) / cd['TotalPlayed']\n\n# The resulting data frame looks like this:\n\n# cd\n\n# For other parts of the project we will want to come back to this data. Let's store it in a new `.csv` file.\n\ncd.to_csv('../data/processed/ChampionStatsDemo.csv',index=False)\n\n\n", "meta": {"hexsha": "e636b381b0dec3c6f22c9a38b4d864b42d3f034a", "size": 8841, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks/08-__-demo_data_cleaning.py", "max_stars_repo_name": "TechLabs-Aachen-e-V/WiSe20_Team_10_Main", "max_stars_repo_head_hexsha": "1bf1fe4cf5065144a5f6f196004cf5ec16585c83", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/08-__-demo_data_cleaning.py", "max_issues_repo_name": "TechLabs-Aachen-e-V/WiSe20_Team_10_Main", "max_issues_repo_head_hexsha": "1bf1fe4cf5065144a5f6f196004cf5ec16585c83", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-04T05:58:44.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-04T05:58:44.000Z", "max_forks_repo_path": "notebooks/08-__-demo_data_cleaning.py", "max_forks_repo_name": "TechLabs-Aachen-e-V/WiSe20_Team_10_Main", "max_forks_repo_head_hexsha": "1bf1fe4cf5065144a5f6f196004cf5ec16585c83", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 56.3121019108, "max_line_length": 500, "alphanum_fraction": 0.7190363081, "include": true, "reason": "import numpy", "num_tokens": 2324, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4532618480153862, "lm_q2_score": 0.1259227631950178, "lm_q1q2_score": 0.05707598435297763}}
{"text": "from IPython.display import HTML\n\nHTML('''<script>\ncode_show=true; \nfunction code_toggle() {\n if (code_show){\n $('div.input').hide();\n } else {\n $('div.input').show();\n }\n code_show = !code_show\n} \n$( document ).ready(code_toggle);\n</script>\nThe raw code for this IPython notebook is by default hidden for easier reading.\nTo toggle on/off the raw code, click <a href=\"javascript:code_toggle()\">here</a>.''')\n\n# Radioactive Decay Interactives\n\nThe following interactive figures were borrowed from [Astro Interactives](https://juancab.github.io/AstroInteractives/) and adapted for easy access into this Jupyter Book. The first one shows the random yet predictable nature of radioactive decay and its use as a time clock.  The second one illustrates Geochron plots. \n\n## Interactive Figure 1: Model of Radioactive Decay\n\nThis first figure takes a population of 900 atoms and models their radioactive decay.\n\nThis first interactive is designed to allow you to explore what happens during radioactive decay of some isotope. An *isotope* refers to a particular version of an element.  For example, the non-radioactive Carbon-12 isotope has 6 protons and 6 neutrons in its nucleus but the radioactive Carbon-14 isotope has 6 protons and 8 neutrons in its nucleus.  Different isotopes of the same element behave identically in terms of chemistry and bonding to other atoms, but their nuclear properties can differ.\n\nDuring radioactive decay, a *parent isotope* is said to decay into a *daughter isotope*.  So, for example, the parent isotope of Carbon-14 decays into Nitrogen-14.  There is no way to predict when any one nucleus of a *parent isotope* will decay into a *daughter isotope*.   That said, if you look at a large number of nuclei of a parent isotope, they exhibit a very simple property:\n\n> **The same *fraction* of a radioactive parent isotope will decay over the same amount of time.**\n    \nThe time it takes for one-half of a population of parent isotopes to decay (on average) into daughter isotopes is called the *half-life* of that isotope.  Different parent isotopes can have very different half-lifes.   **NOTE:** This interactive shows a simulation of the decay of only 900 atoms.  The radioactive decay is still modelled as occurring randomly for any one atom, so the simulation will show slightly different results on different runs!!\n\nSome questions to consider \n1. After 1 half-life, about 50% of a parent isotope should have decayed and become daughter isotope.  Use the interactive graphic below and adjust the elapsed time to figure out how long one half-life is for each isotope.  Explain your approach.\n2. How much of a parent isotope is left after 2 half-lifes? 3 half-lifes? 4 half-lifes? 5 half-lifes?  Explain how you figured this out.\n3. You should have found about 25% of the original amount of parent isotope is left after 2 half-lifes.  This may seem surprising since in the first half-life 50% of the original amount of parent isotope decayed.  Explain why 'less' of it decayed during the second half-life.  **HINT** Consider the very simple property of radioactive decay we highlighted above.\n\nfrom IPython.display import display\nimport numpy as np\nimport bqplot as bq\nimport ipywidgets as widgets\nimport random as random\nimport pandas as pd\nimport number_formatting as nf\nfrom math import ceil, floor, log10\n\n## Originally developed June 2018 by Samuel Holen\n##\n## Edits by Juan Cabanela October 2018 to allow changes in the GUI.\n## - Made the display of the precise number/faction of parent/daught atoms instructor\n##   configurable.\n## - Fixed a problem with the display of data, forced data to only be displayed for first\n##   10 half-lifes regardless of actual generated decay times (this allows hard-coding of)\n##   num_ticks and tick values.\n\n## Pre-construct model of radioactive decay of a population\n## of parent and daughter atoms.\n## \n\n# GUI Configuration Parameters\nshow_counts = True\nmax_half_lifes = 10   # maximum half-lives to graph\ntime_ticks = 6  # number of ticks for the time axis\n# half-lives to place ticks on horizontal axis\nhalf_life_ticks = np.linspace(0, max_half_lifes, time_ticks)\n\n# Constants Related to decay of the parent species to the daughter species\nN_parent = 900          # initial number of parent atoms (should be a perfect square)\nN_daughter = 0          # initial number of daughter atoms\ntau = 1                 # placeholder for the half-life of the parent species \nh = 0.025               # time step (in half lives)\nmu = np.log(2.) / tau   # constant for decay time distribution \nPlot_all_times = True   # Plot all times (otherwise, selects only before time slider value)\n\n# Initialize tracking of number of atoms\nParent_counts = []          # list of number of parent atoms \nDauther_counts = []          # list of number of daughter atoms\n\n# Generate a uniform random distribution of N_parent numbers from 0 to 1\nz = np.random.rand(N_parent)\n\n# Function to convert uniform distribution of random numbers to\n# a distribution weighted to model radiactive decay. The times are in number of \n# half-lives. \n#\n# The unsorted data representing the number of half-lifes until the individual\n# decay of each atom.\ndecay_times = -np.log(1 - z) / mu\ndecay_times_sorted = np.sort( decay_times )\n\n# Genereate array of numbers of atoms left\n# Adjusted so that each count contains 0 and N_parent\nParent_counts = np.arange(N_parent,-1, -1, dtype='int') # Number of parent atoms\nDaughter_counts = np.ones_like(Parent_counts)\nDaughter_counts = N_parent - Parent_counts   # Number of daughter atoms\n\n#\n# Construct Pandas data frames\n#\n\n# Time column adjusted to include t=0\ndecay_data = pd.DataFrame()\ndecay_data['time'] = np.concatenate((np.zeros(1), decay_times_sorted))\ndecay_data['Parent'] = Parent_counts\ndecay_data['Daughter'] = Daughter_counts\n\n# Data array for species\nspecies = pd.DataFrame()\nspecies['parent_long'] = ['Generic', 'Carbon', 'Thallium','Uranium','Rubidium']\nspecies['daughter_long'] = ['Generic', 'Nitrogen','Lead','Thorium','Strontium']\nspecies['parent_short'] = ['Parent', 'C-14','Tl-208','U-235','Rb-87']\nspecies['daughter_short'] = ['Daughter', 'N-14','Pb-208','Th-231','Sr-87']\nspecies['half-lives'] = [tau, 5730, 3.053 * 60, 703.8, 48.8]\nspecies['step-size'] = [h, 125, 0.05 * 60, 15, 1]\nspecies['timeunits'] = ['half-lives', 'years', 'seconds', 'million years', 'billion years']\n\n##\n## Define functions to respond to controls on population plots.\n##\n\ndef UpdateSpecies(change=None):\n    ##\n    ## Deal with possible changes of species\n    ##\n    \n    # Generate a new uniform random distribution of N_parent numbers from 0 to 1 and\n    # then convert uniform distribution to one weighted to model radioactive decay.\n    z = np.random.rand(N_parent)\n    decay_times = -np.log(1 - z) / mu\n    decay_times_sorted = np.sort( decay_times )\n    decay_data['time'] = np.concatenate((np.zeros(1), decay_times_sorted))\n    \n    # Reset the time to zero\n    Time_slide.value = 0\n    \n    # Adjust half-life data and limits on plots appropriately \n    new_index = species.loc[species.parent_long == pick_Species.value].index[0]\n    \n    # Set the half-life based the selected species\n    hf = species['half-lives'][new_index]\n    \n    # Set the limit on the time sider to be 10 half-lifes\n    Time_slide.max = max_half_lifes*hf\n    \n    # Set the time step on slider\n    Time_slide.step = species['step-size'][new_index]\n\n    # Updates the time slider label/units\n    unit_label.value = species['timeunits'][new_index]\n    \n    # Updates the time axes on the plot\n    x_time.max = Time_slide.max\n    ax_x_time.scale = x_time\n    ax_x_time.label = unit_label.value\n    \n    # Update tick values\n    ax_x_time.tick_values = list(half_life_ticks*hf)\n\n    # Update the legend\n    parent_label_new = species['parent_short'][new_index]\n    daughter_label_new = species['daughter_short'][new_index]\n    line_parent.labels = [parent_label_new]\n    line_daughter.labels = [daughter_label_new]\n    \n    # Update the species in the box that shows how many are present    \n    parent_label.value = parent_label_new + ' produced'\n    daughter_label.value = daughter_label_new + ' remaining'\n\n    # Now call the function for updating the plot in the event of a time change\n    UpdateTimes()\n\n    \ndef UpdateFraction(change=None):\n    ##\n    ## Deal with whether fraction view or number view selected to set scales for plot,\n    ## y values for plot, and label values\n    ##\n    if frac_or_num.value == False:\n        # Number count mode enabled\n\n        # Update axes and scales\n        fig_counts.axes = [ax_x_time, ax_y_number]\n        line_parent.scales={'x': x_time, 'y': y_number}\n        line_daughter.scales={'x': x_time, 'y': y_number}\n        pts_parent.scales={'x': x_time, 'y': y_number}\n        pts_daughter.scales={'x': x_time, 'y': y_number}\n        line_time.scales={'x': x_time, 'y': y_number}\n\n        # Update 'time line' limits\n        line_time.y = [0, N_parent]    \n    else:\n        # Fraction mode enabled\n\n        # Updated axes and scales\n        fig_counts.axes = [ax_x_time, ax_y_fraction]\n        line_parent.scales={'x': x_time, 'y': y_fraction}\n        line_daughter.scales={'x': x_time, 'y': y_fraction}\n        pts_parent.scales={'x': x_time, 'y': y_fraction}\n        pts_daughter.scales={'x': x_time, 'y': y_fraction}\n        line_time.scales={'x': x_time, 'y': y_fraction}\n\n        # Update 'time line' limits\n        line_time.y = [0, 1]\n\n    UpdateTimes()\n\n    \ndef UpdateTimes(change=None):\n    ##\n    ## Deal with changes in the time slider\n    ##\n\n    # Recall half-life of this species\n    species_idx = species.loc[species.parent_long == pick_Species.value].index[0]\n    hf = species['half-lives'][species_idx]\n\n    # Update time label with 3 significant figures\n    Time_label.value = str(nf.SigFig(Time_slide.value, 3))\n        \n    # Get the array of times\n    time_arr = hf * decay_data['time']\n    \n    # Set the times to be x values\n    line_daughter.x = time_arr\n    line_parent.x = line_daughter.x\n    pts_daughter.x = line_daughter.x\n    pts_parent.x = line_daughter.x\n    line_time.x = [Time_slide.value, Time_slide.value]\n    \n    # Changes the color of population to reflect the decays\n    for i in range(N_parent):\n        if Time_slide.value >= decay_times[i]*hf:\n            Colors[i] = 'blue'\n        else:\n            Colors[i] = 'red'\n    population_scat.colors = Colors\n    \n    # Identify where we are in the data set\n    i = 0\n    while i < N_parent + 1 and hf*decay_data['time'][i] < Time_slide.value:        \n        i += 1\n    if i > 0:\n        i -= 1\n        \n    # Update selection of the parent and daughter data to be plotted\n    if Plot_all_times:\n        daughter_decay = decay_data['Daughter']\n        parent_decay = decay_data['Parent']\n    else:\n        daughter_decay = decay_data['Daughter'][0:i+1]\n        parent_decay = decay_data['Parent'][0:i+1] \n    \n    line_parent.y = parent_decay\n    line_daughter.y = daughter_decay\n        \n    ##\n    ## Deal with whether fraction view or number view selected to set scales for plot,\n    ## y values for plot, and label values\n    ##\n    if frac_or_num.value == False:\n        # Number count mode enabled\n\n        # Update number of parent and daughter in labels\n        parent_present.value = str(decay_data['Parent'][i])\n        daughter_present.value = str(decay_data['Daughter'][i])\n    else:\n        # Fraction mode enabled\n        \n        # Update the x and y arrays for the parent and daughter lines\n        line_parent.y = (1/N_parent)*parent_decay\n        line_daughter.y = (1/N_parent)*daughter_decay\n    \n        # Update number of parent and daughter in labels\n        parent_present.value = '{:.3f}'.format((1/N_parent)*decay_data['Parent'][i])\n        daughter_present.value = '{:.3f}'.format((1/N_parent)*decay_data['Daughter'][i])\n    \n    # Update parent and daughter lines\n    pts_parent.y = line_parent.y\n    pts_daughter.y = line_daughter.y\n    \n    # Update the tooltip labels and formats (Bug? Doesn't appear to be working)\n    #pts_parent.tooltip.labels[1] = parent_label_new\n    #pts_daughter.tooltip.labels[1] = daughter_label_new\n    #if frac_or_num.value == False:\n    #    pts_parent.tooltip.formats[1] = '3.0f'\n    #    pts_daughter.tooltip.formats[1] = '3.0f'\n    #else:\n    #    pts_parent.tooltip.formats[1] = '0.3f'\n    #    pts_daughter.tooltip.formats[1] = '0.3f'\n        \n\n\n##\n## Set up counts versus time plot\n##\n\n# Set up Species to be Generic\ninit_species_ind = 0  \n\n# Set up initial time\ninit_time = 0\ninit_time_idx = 0\n\n# Set up axes\nx_time = bq.LinearScale(min = 0, max=max_half_lifes)\ny_number = bq.LinearScale(min = 0, max=N_parent)\ny_fraction = bq.LinearScale(min = 0, max=1)\n\n# Labels and scales for Axes\nax_x_time = bq.Axis(label=species['timeunits'][init_species_ind], scale=x_time, num_ticks = time_ticks,\n                    tick_values = half_life_ticks )\nax_y_number = bq.Axis(label='Number of atoms', scale=y_number, orientation='vertical')\nax_y_fraction = bq.Axis(label='Fraction of atoms', scale=y_fraction, orientation='vertical')\n\n# Define tooltip (Bug: doesn't allow relabeling Tooltips, also needs to apply to Scatter, not Lines)\n#def_tt_parent = bq.Tooltip(fields=['x', 'y'], formats=['.2f', '3.0f'], labels=['time', species['parent_short'][init_species_ind]])\n#def_tt_daughter = bq.Tooltip(fields=['x', 'y'], formats=['.2f', '3.0f'], labels=['time', species['daughter_short'][init_species_ind]])\ndef_tt_parent = bq.Tooltip(fields=['x', 'y'], formats=['.2f', '.3f'], labels=['time', 'amount of parent isotope'])\ndef_tt_daughter = bq.Tooltip(fields=['x', 'y'], formats=['.2f', '.3f'], labels=['time', 'amount of daughter isotope'])\n\n# Define the Lines and Scatter plots\n# NOTE: Scatter only necessary to allow tooltips to function.\ninit_x = decay_data['time']*species['half-lives'][init_species_ind]\nif Plot_all_times:\n    init_parent = decay_data['Parent']\n    init_daughter = decay_data['Daughter']\nelse:\n    init_parent = decay_data['Parent'][0:init_time_idx]\n    init_daughter = decay_data['Daughter'][0:init_time_idx]\n    \npts_parent = bq.Scatter(x=init_x, y=init_parent,\n                      scales={'x': x_time, 'y': y_number}, marker='circle', default_size=2,\n                      display_legend=False, colors=['red'], labels=[species['parent_short'][init_species_ind]], \n                      tooltip=def_tt_parent)\npts_daughter = bq.Scatter(x=init_x, y=init_daughter,\n                        scales={'x': x_time, 'y': y_number}, marker='circle', default_size=2,\n                        display_legend=False, colors=['blue'], labels=[species['daughter_short'][init_species_ind]],\n                        tooltip=def_tt_daughter)\nline_parent = bq.Lines(x=init_x, y=init_parent, \n                       scales={'x': x_time, 'y': y_number}, display_legend=True, colors=['red'], \n                       labels=[species['parent_short'][init_species_ind]], )\nline_daughter = bq.Lines(x=init_x, y=init_daughter, \n                         scales={'x': x_time, 'y': y_number}, display_legend=True, colors=['blue'], \n                         labels=[species['daughter_short'][init_species_ind]] )\n\n# Set up a vertical line on this plot to indicate the current time\ntimes_x = [init_time, init_time]\ntimes_y = [0, N_parent]\nline_time = bq.Lines(x=times_x, y=times_y,\n                     scales={'x': x_time, 'y': y_number}, \n                     colors=['greenyellow'])\n\n# Creates figure for plot\nfig_counts = bq.Figure(axes=[ax_x_time, ax_y_number], marks=[line_parent, line_daughter, line_time, pts_parent, pts_daughter], \n                       legend_location='right', legend_style={'fill': 'white'}, \n                       title='Counts versus Time', background_style={'fill': 'black'}, \n                       layout={'width': '500px', 'min_height': '400px'},\n                      animation=1000)\n\n# Slider widget to control the amount of time that has passed\n# Set for generic half-life situation initially (0 to 10 half-lifes)\nTime_slide = widgets.FloatSlider(\n    value=0.,\n    description='Time',\n    min=0.,\n    max=max_half_lifes,\n    step=h,\n    disabled=False,\n    continuous_update=False,\n    orientation='horizontal',\n    readout=False,\n    readout_format='.1f',\n    layout=widgets.Layout(overflow_x='visible',\n                          overflow_y='visible',\n                          width='400px',\n                          max_width='500px',\n                          min_width='250px')\n)\n\n# Widget to display the number of parent atoms present\nparent_present = widgets.Text(\n    value = str(N_parent),\n    style = {'description_width': 'initial'},\n    #description = species['parent_short'][0]+' remaining',\n    disabled = True,\n    layout=widgets.Layout(overflow_x='visible',\n                          overflow_y='visible',\n                          width='175px',\n                          max_width='300px',\n                          min_width='125px')\n)\n\n# Widget to display the number of daughter atoms present\ndaughter_present = widgets.Text(\n    value = str(0),\n    style = {'description_width': 'initial'},\n    #description = species['daughter_short'][0]+' produced',\n    disabled = True,\n    layout=widgets.Layout(overflow_x='visible',\n                          overflow_y='visible',\n                          width='175px',\n                          max_width='300px',\n                          min_width='125px')\n)\n\n# Widgets to label the time slider with units\nTime_label = widgets.Label(value=str(Time_slide.value))\nunit_label = widgets.Label(value=str(species['timeunits'][0]))\nComposite_Time_Label = widgets.HBox([Time_label, unit_label],\n                                   layout=widgets.Layout(width='200px'))\n\n# Labels for the parent/daughter present displays\nparent_label = widgets.Label(value=species['parent_short'][0]+' remaining',\n                             layout=widgets.Layout(width='200px', \n                                                   overflow_x='visible',\n                                                   overflow_y='visible') )\ndaughter_label = widgets.Label(value=species['daughter_short'][0]+' produced',\n                             layout=widgets.Layout(width='200px', \n                                                   overflow_x='visible',\n                                                   overflow_y='visible') )\n\n# Checkbox to choose whether to display the number of each species\n# or the fraction of each\nfrac_or_num = widgets.Checkbox(value=False, description='Display as fraction of atoms')\n\n# Widget to allow one to choose which species to work with\npick_Species = widgets.RadioButtons(options=species['parent_long'][:],\n                                    value='Generic', description='Species:', disabled=False,\n                                    layout=widgets.Layout(width='250px'))\n\n\n# Scale for population figure\nx_sc = bq.LinearScale(min=1, max=np.sqrt(N_parent))\ny_sc = bq.LinearScale(min=1, max=np.sqrt(N_parent))\n\n# Axes for population figure\nax_x = bq.Axis(scale=x_sc, num_ticks=0)\nax_y = bq.Axis(scale=y_sc, orientation='vertical', num_ticks=0)\n\n# Creates an array of x values: [1,2,...,30,1,2,...30,.....,1,2,...,30]\nx_ls = []\nfor i in range(1,int(np.sqrt(N_parent))+1):\n    x_ls.append(float(i))\nx_ls = x_ls * int(np.sqrt(N_parent))\nx_arr = np.array(x_ls)\n\n# Creates an array of y values: [1,1,...,1,2,2,...2,......,30,30,...,30]\ny_ls = []\nfor i in range(1,int(np.sqrt(N_parent))+1):\n    y_ls += [float(i)] * int(np.sqrt(N_parent))\ny_arr = np.array(y_ls)    \n\n# Creates a color array with the same number of entries as the number of atoms in\n# the sample\nColors = ['red'] * N_parent\n\n# Plot the population model\npopulation_scat = bq.Scatter(x=x_arr, y=y_arr, scales={'x': x_sc, 'y': y_sc}, colors =['red'])\n\n# Picking a new species resets everything\npick_Species.observe(UpdateSpecies, names=['value'])\n\n# Update view from fraction to/from number\nfrac_or_num.observe(UpdateFraction, names=['value'])\n\n# Update times\nTime_slide.observe(UpdateTimes, names=['value'])\nTime_label.observe(UpdateTimes, names=['value'])\n\n# Figure for the population\nfig_population = bq.Figure(title='Population of Atoms', marks=[population_scat], axes=[ax_x, ax_y], \n                background_style={'fill' : 'black'},padding_x = 0.025,\n                min_aspect_ratio=1, max_aspect_ratio=1)\n\n# Boxes to organize display\nparent_box = widgets.HBox([parent_label, parent_present],\n                          layout=widgets.Layout(overflow_x='visible', overflow_y='visible'))\ndaughter_box = widgets.HBox([daughter_label, daughter_present],\n                            layout=widgets.Layout(overflow_x='visible', overflow_y='visible'))\n# Set visibility of the exact counts/fractions\nif (show_counts == False):\n    parent_box.layout.visibility = 'hidden'\n    daughter_box.layout.visibility = 'hidden'\n\nvalue_box = widgets.VBox([parent_box, daughter_box])\nspecies_box = widgets.HBox([value_box, pick_Species])\n\nslide_box = widgets.HBox([Time_slide, Composite_Time_Label])\nslide_check_box = widgets.VBox([slide_box, frac_or_num])\n\ntop_box = widgets.HBox([fig_counts, fig_population],\n                      layout=widgets.Layout(width='900px'))\ntop_box.children[0].layout.width = '450px'\ntop_box.children[1].layout.width = '450px'\n\nbottom_box = widgets.HBox([species_box, slide_check_box],\n                      layout=widgets.Layout(width='900px'))\nbottom_box.children[0].layout.width = '450px'\nbottom_box.children[1].layout.width = '450px'\n\n# Final display\nFinal = widgets.VBox([top_box, bottom_box])\nFinal.layout.overflow = 'hidden'\ndisplay(Final)\n\n## Interactive Figure 2: Geochron Plot\n\nAssuming a non-radiogenic isotope (that is, an isotope that is not the result of radioactive decay) that also will not decay, its amount should be constant.  This means that for different mineral samples we can measure the ratio of parent isotope versus the non-radiogenic isotope ($P/D_i$) and daughter isotope ($D$) versus the non-radiogenic isotope ($D/D_i$) to build an geochron plot.  For example, using the following isotopes\n\n- $D_i$ (non-radiogenic isotope of daughter element)\n- $D$ (Daughter Isoptope)\n- $P$ (Parent isotope)\n\nan geochron plot could plot $D/D_i$ versus $P/D_i$.  \n\nWhat sets the *geochron method* (also known as the *isochron method*) apart from the just measuring parent and daughter abundances is the use of the non-radiogenic isotope of the daughter element.  This avoids the assumption of no initial daughter isotope before the rock solidified (radioactive decay can occur while rock is molten).\n\nSome minerals in the rock incorporate the parent better than daughter which is why the initial amount of parent \nisotope versus daughter isotope can vary.  We expect daughter versus non-radiogenic isotope ratio to be constant\nif we pick the non-radiogenic isotope to be the same element as the daughter isotope.\n\nWith all this said, it is actually often not this simple as many daughter isotopes are themselves radioactive and decay, leading to a chain of reactions, so comparing abundances of parent to daughter isotopes is not simple.\n\n*Note:* The idea for the geochron dating interactive came from a Isochron Diagram Java app at *ScienceCourseware.org*.  However that app had some issues in that it didn't divide by a non-radiogenic isotope (or at least didn't mention it).  In fact, they used $D_i$ for the initial amount of daughter isotope instead of the non-radiogenic isotope of the same element as the daughter isotope.\n\nConsider the following questions:\n\n1. Notice that the geochron shown here is using the parent and daugther isotope ratios for 4 mineral samples in a rock.  Consider the sample that starts off with the most parent isotope initially (the point initially farthest to the right).  Adjust the geochron to show the samples after 1 half-life.  How much of that parent isotope was there initially?  How much is there after 1 half-life?  Does this make sense? \n2. Consider the sample that starts off with the least parent isotope initially (the point initially farthest to the left).  Adjust the geochron to show the samples after 1 half-life.  How much of that parent isotope was there initially?  How much is there after 1 half-life?  Does this make sense? \n3. What fraction of the parent isotope should have decayed into daughter isotope after one half-life?  Does it matter if the mineral sample we look at started with more parent isotope than another mineral sample in the same rock?  Why or why not?  \n4. Why is it as time elapses that the points representing the 4 mineral samples all move toward the upper left?  Can you explain why their motions are parallel to one another?\n4. Imagine you are looking at the parent isotope Rubidium-87 which decays into Strontium-87.  You examine 4 mineral samples in an meteorite and they line up in a line with a slope of 0.0666.  Determine the age of that meteorite (or rather, the time since it solidified).  Also explain how we can determine how much of the daughter isotope was in the meteorite initially.\n\n\n##\n## Define the various isotopes we want to consider\n##\n\nisotope_info = pd.DataFrame(columns=['Name', 'PName', 'PAbbrev', 'DName', 'DAbbrev', 'DiName', 'DiAbbrev', 'HalfLife', 'HLUnits'])\nisotope_info['index'] = ['generic', 'Rb87']\nisotope_info['Name'] = ['Generic', 'Rb-87->Sr-87']\nisotope_info['PName'] = ['Parent', 'Rubidium-87']\nisotope_info['PAbbrev'] = ['P', 'Rb-87']\nisotope_info['DName'] = ['Daughter', 'Strontium-87']\nisotope_info['DAbbrev'] = ['D', 'Sr-87']\nisotope_info['DiName'] = ['Non-Radiogenic Isotope of Daughter Element', 'Strontium-86']\nisotope_info['DiAbbrev'] = ['D_i', 'Sr-86']\nisotope_info['HalfLife'] = [ 1, 48.8 ]\nisotope_info['HLUnits'] = [ 'half-lives', 'Billion years']\nisotope_info = isotope_info.set_index('index')\n\n# Set initial isotope to plot\ninit_isotope = 'generic'\n\n##\n## Define the initial amounts of parent and daughter in the sample.\n##\n## In principle, I would change this depending on the isotopes we plot.  But I am only plotting\n## Rb87 --> Sr-87, since that is the most classical use of this Geochron approach.\n##\n\n# Range of P to D_i fractions and initial amounts of D to D_i to consider\nP2Di_min = 0.05\nP2Di_max = 0.40\nD2Di0_min = 0.05\nD2Di0_max = 0.75\n\n# Generate three mineral samples in different thirds of the entire range\nrange_P2Di  = (P2Di_max-P2Di_min)\n\n# Create sample amounts\nn_samples = 4\nnums = np.array(list(range(1, n_samples+1)))\ninitial_samples = pd.DataFrame(index=nums)\ninitial_D2Di0 = D2Di0_min + (D2Di0_max - D2Di0_min) * np.random.random()\ninitial_samples['P2Di'] = P2Di_min + (range_P2Di/n_samples) * (nums - np.random.random(n_samples))\ninitial_samples['D2Di'] = initial_D2Di0*np.ones_like(nums)\n\n\n##\n## Define functions to call when building interactive plot\n##\n\ndef amt_left(sample_in, taus):\n    # Generate a sample DataFrame after tau half-lifes given an initial DataFrame\n    sample = sample_in.copy(deep = True)\n    sample['P2Di'] = sample_in['P2Di']*((1/2)**(taus))\n    sample['D2Di'] = sample_in['D2Di'] + sample_in['P2Di']*(1 - (1/2)**(taus))\n    return sample\n\ndef line_points(sample):\n    global x_min, x_max, y_min, y_max, initial_D2Di0\n    \n    # Determine the end points of a line going through the sample points.\n    x_range = x_max - x_min\n    y_range = y_max - y_min\n    \n    # Slope (extrapolate from first two points - could be done by a fit to the points)\n    slope = (sample['D2Di'][2]-sample['D2Di'][1])/(sample['P2Di'][2]-sample['P2Di'][1])\n    y_final = initial_D2Di0 + slope*x_range\n    x_points = (x_min, x_max)\n    y_points = (initial_D2Di0, y_final)\n    return x_points, y_points, slope\n\ndef init2current(samples0, samples):\n    # Compute the lines connecting initital and final points for plotting\n    n_pts = len(samples0)\n\n    xlist = []\n    ylist = []\n    for pt in range(1, n_pts+1):\n        x = np.array([ samples0['P2Di'][pt], samples['P2Di'][pt] ])\n        y = np.array([ samples0['D2Di'][pt], samples['D2Di'][pt] ])\n        xlist.append(x)\n        ylist.append(y)\n    \n    return(xlist, ylist)\n    \ndef HL_changed(change):\n    global isotope, sample, initial_samples, dots_current, line_current, connectors, slope_label\n    \n    # Determine half-life of this isotope\n    idx = (isotope_info.Name == isotope.value)\n    HL = float(isotope_info[idx].HalfLife.tolist()[0])\n    \n    # How many half-lives have passed?  Use this to get new sample and line info\n    this_tau = HL_slider.value / HL\n    sample = amt_left(initial_samples, this_tau)\n    x_sample, y_sample, slope =  line_points(sample)\n    \n    # Update plot\n    dots_current.x = sample['P2Di']\n    dots_current.y = sample['D2Di']\n    line_current.x = x_sample\n    line_current.y = y_sample\n    slope_label.value = 'Slope: {0:0.4f}'.format(slope)\n    xlist, ylist = init2current(initial_samples, sample)\n    connectors.x = xlist\n    connectors.y = ylist\n    \n    \ndef isotope_changed(change):\n    global ax_x_P2Di, ax_y_D2Di, HL_slider, HLlabel, UnitsText, Max_half_lives\n\n    # Extract the necessary isotope descriptors from the Pandas DataFrame\n    idx = (isotope_info.Name == change.new)\n    HL = float(isotope_info[idx].HalfLife.tolist()[0])\n    HLUnits = isotope_info[idx].HLUnits.tolist()[0]\n    PAbbrev = isotope_info[idx].PAbbrev.tolist()[0]\n    DAbbrev = isotope_info[idx].DAbbrev.tolist()[0]\n    DiAbbrev = isotope_info[idx].DiAbbrev.tolist()[0]\n\n    # Get old half-life\n    idx_old = (isotope_info.Name == change.old)\n    HL_old = float(isotope_info[idx_old].HalfLife.tolist()[0])\n\n    # Determine current age reading from slider and adjust to new units\n    init_age = HL_slider.value \n    \n    # Hard code generic versus others\n    if (change.new != isotope_info.loc['generic'].Name):\n        HL_slider.description = \"Time\"\n    else: \n        HL_slider.description = \"Half-lives\"    \n\n    # Adjust time scales\n    if (HL_old < HL):\n        # Adjust maximum limits first before adjusting values (since new HL > old HL)\n        HL_slider.max = Max_half_lives*HL\n        HLlabel.max = HL_slider.max \n        HL_slider.value = HL*(init_age/HL_old)\n        HLlabel.value = HL_slider.value       \n    else:\n        # Adjust maximum limits after adjusting values (since new HL < old HL)\n        HL_slider.value = HL*(init_age/HL_old)\n        HLlabel.value = HL_slider.value\n        HL_slider.max = Max_half_lives*HL\n        HLlabel.max = HL_slider.max \n                \n    # Set the axes and other labels to display\n    UnitsText.value = HLUnits\n    ax_x_P2Di.label = '{0} / {1}'.format(PAbbrev, DiAbbrev)\n    ax_y_D2Di.label = '{0} / {1}'.format(DAbbrev, DiAbbrev)\n\n\n\n##\n## Set up isochron plot\n##\n\n# Largest possible fraction of decay (only go out to 5 half-lives)\nMax_half_lives = 5\nMax_decay_fraction = 1 - (1/2)**(Max_half_lives)\n\n# detemine maximum and minimum values of X and Y axes\nx_step = 0.05\nx_min = 0\nx_max = x_step * ceil(initial_samples['P2Di'][n_samples] / x_step)\ny_step = 0.04\ny_min = y_step * floor(initial_D2Di0 / y_step)\ny_max = y_step * ceil((initial_D2Di0 + initial_samples['P2Di'][n_samples] * Max_decay_fraction) / y_step)\n\n# Labels and scales for Axes\nx_P2Di = bq.LinearScale(min = x_min, max = x_max)\ny_D2Di = bq.LinearScale(min = y_min, max = y_max)\nax_x_P2Di = bq.Axis(label='P / D_i', scale=x_P2Di)\nax_y_D2Di = bq.Axis(label='D / D_i', scale=y_D2Di, orientation='vertical')\n\n# Set up initial conditions\ntaus = 0    # zero half lives past\nsample = amt_left(initial_samples, taus)\n\n##\n## Define the lines\n##\n\n# Initial amount of daughter line (with dots for initial amounts of parent)\nx_init, y_init, slope_init =  line_points(initial_samples)\nline_initial = bq.Lines(x=x_init, y=y_init, scales={'x': x_P2Di, 'y': y_D2Di}, \n                   line_style='dashed', colors=['red'], labels=['Initial Sample'])\ndots_initial = bq.Scatter(x=initial_samples['P2Di'], y=initial_samples['D2Di'], scales={'x': x_P2Di, 'y': y_D2Di}, \n                   colors=['white'], stroke='red', fill= True, labels=['Initial Isochron'])\n\n# Current quantities on isochron line\nx_sample, y_sample, slope =  line_points(sample)\nline_current = bq.Lines(x=x_sample, y=y_sample, scales={'x': x_P2Di, 'y': y_D2Di}, \n                   line_style='solid', colors=['red'], labels=['Current Isochron'])\ndots_current = bq.Scatter(x=sample['P2Di'], y=sample['D2Di'], scales={'x': x_P2Di, 'y': y_D2Di}, \n                   colors=['red'], stroke='red', fill= True, labels=['Current Isochron'])\n\n# Connect Initial and Current quantities on isochron line\nxlist, ylist = init2current(initial_samples, sample)\nconnectors = bq.Lines(x=xlist, y=ylist, scales={'x': x_P2Di, 'y': y_D2Di}, \n                   line_style='dotted', colors=['black'])\n\n##\n## Construct plot\n##\nisochron = bq.Figure(axes=[ax_x_P2Di, ax_y_D2Di], \n                     marks=[connectors, line_initial, dots_initial, line_current, dots_current],\n                     title='Geochron Diagram', \n                     layout={'width': '700px', 'height': '500px', \n                             'max_width': '700px', 'max_height': '500px',\n                             'min_width': '600px', 'min_height': '400px'})\n\n##\n## Construct controls\n##\n\n# Select Generic or Specific Isotopes\nisotope = widgets.RadioButtons(options=list(isotope_info.Name), \n                               value=isotope_info.loc[init_isotope].Name, description='Isotope:', \n                               disabled=False, \n                               layout=widgets.Layout(height='75px', max_height='100px', min_height='50px', \n                                                    width='200px', max_width='300px',  min_width='100px'))\nisotope.observe(isotope_changed, 'value')\n\n# Slider and text field controling age\nidx = (isotope_info.Name == isotope.value)\nHL = float(isotope_info[idx].HalfLife.tolist()[0])\nHLUnits = isotope_info[idx].HLUnits.tolist()[0]\n\nHL_slider = widgets.FloatSlider(value=0, min=0, max=Max_half_lives*HL, step=0.02,\n                                description='Half-lives', disabled=False,\n                                continuous_update=False, orientation='horizontal',\n                                readout=False, readout_format='.2f',\n                                layout=widgets.Layout(height='75px', max_height='100px', min_height='50px', \n                                                    width='200px', max_width='300px',  min_width='100px'))\nHL_slider.observe(HL_changed, 'value')\n\n# Get units value and units for age label, then apply them\nHLlabel = widgets.BoundedFloatText(value = HL_slider.value, min = HL_slider.min, max = HL_slider.max, \n                                   step = HL_slider.step,\n                                       layout={'width': '75px', 'height': '50px', \n                                               'max_width': '75px', 'max_height': '75px',\n                                               'min_width': '50px', 'min_height': '50px'})\nUnitsText = widgets.Label(value=HLUnits)\nage_label = widgets.HBox([HLlabel, UnitsText])\n# Link HL slider with this text\nwidgets.jslink((HL_slider, 'value'), (HLlabel, 'value'))\n\n# Describe slope\nslope_label = widgets.Label(value = 'Slope: {0:0.4f}'.format(slope),\n                                       layout={'align_items':'center','align_content':'center', \n                                               'justify_content':'center', \n                                               'width': '100px', 'height': '50px', \n                                               'max_width': '100px', 'max_height': '75px',\n                                               'min_width': '50px', 'min_height': '50px'})\n\n\ncontrols = widgets.VBox( [isotope, HL_slider, age_label, slope_label], \n                        layout=widgets.Layout(align_content='center', align_items='center', \n                                              justify_content='center', \n                                              width='300px', height='500px', \n                                              max_width='300px', max_height='500px',\n                                              min_width='100px', min_height='400px',\n                                              overflow_x='hidden', overflow_y='hidden') )\n\ndisplay(widgets.HBox( [isochron, controls] ) )", "meta": {"hexsha": "a81f82ee85b41aa0d4e1c704c14b082c1db05f7f", "size": 36144, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/content/02/Radioactivity.py", "max_stars_repo_name": "edur409/ASTROBIOLOGY200", "max_stars_repo_head_hexsha": "868d02a10b4be5f71935325c43e89b02567e4e26", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_build/jupyter_execute/content/02/Radioactivity.py", "max_issues_repo_name": "edur409/ASTROBIOLOGY200", "max_issues_repo_head_hexsha": "868d02a10b4be5f71935325c43e89b02567e4e26", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/content/02/Radioactivity.py", "max_forks_repo_name": "edur409/ASTROBIOLOGY200", "max_forks_repo_head_hexsha": "868d02a10b4be5f71935325c43e89b02567e4e26", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.18, "max_line_length": 501, "alphanum_fraction": 0.6671093404, "include": true, "reason": "import numpy", "num_tokens": 8967, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.27825679370240214, "lm_q2_score": 0.20434189751412138, "lm_q1q2_score": 0.05685952122134427}}
{"text": "#!/usr/bin/python\n# -*- coding utf-8 -*-\n\n\n\n#                                                 \n# Gerade - Klasse  von agla           \n#                                                 \n\n#\n# This file is part of agla\n#\n#\n# Copyright (c) 2019 Holger Böttcher  hbomat@posteo.de\n#\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\")\n# you may not use this file except in compliance with the License\n# You may obtain a copy of the License at\n#  \n#      http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#  \n\n\n\nimport importlib\n\nimport numpy as np\nfrom agla.lib.objekte.umgebung import UMG\t\nif UMG.grafik_3d == 'mayavi':\n    from mayavi import mlab\nelse:\n    from vispy import scene\nimport matplotlib.pyplot as plt\n\nfrom IPython.display import display, Math\n\nfrom sympy.core.sympify import sympify\nfrom sympy.core.containers import Tuple\nfrom sympy.functions.elementary.miscellaneous import sqrt\nfrom sympy.simplify.simplify import simplify, nsimplify\nfrom sympy.core.symbol import Symbol, symbols \nfrom sympy.solvers.solvers import solve\nfrom sympy.core.evalf import N\t \nfrom sympy.core.function import expand\nfrom sympy import Min, Max\nfrom sympy.polys.polytools import Poly\nfrom sympy.printing import latex\nfrom sympy.core.numbers import Integer, Float\n\nfrom agla.lib.objekte.basis import AglaObjekt\nfrom agla.lib.funktionen.funktionen import (is_zahl, mit_param, kollinear, \n     Gleichung, orthogonal, loese, wert_ausgabe)\nfrom agla.lib.funktionen.graf_funktionen import hex2color, _funkt_sympy2numpy\nfrom agla.lib.objekte.ausnahmen import AglaError\nimport agla\n\n\t\n\n# Gerade - Klasse  \n# ---------------                                   \n                                 \nclass Gerade(AglaObjekt):    \n    \"\"\"Gerade im Raum und in der Ebene\n\t\n**Erzeugung im Raum und in der Ebene** \n\n   Gerade ( *stütz, richt /[, par ]* )\n\n   *oder* \n\t\n   Gerade ( *schar /[, par ]* ) \n\t\n**Erzeugung nur in der Ebene** \n\n   Gerade ( *m, n* )\n   \n   *oder*\n\n   Gerade ( *a, b, c* )\n   \n**Parameter**\t\n\t\n   *stütz* :    Stützvektor\n\t  \n   *richt* :    Richtungsvektor\n   \n   *par* :      Geradenparameter; *t* falls nicht angegeben\n\n   *schar*:    \n      | Punkteschar, die eine Gerade bildet\n      | *par* muss bei mehr als einem Parameter in *schar* \n        angegeben werden   \n\n   *m, n* :     Koeffizienten der Gleichung  *y=mx+n*\n\t\t\t\t\n   *a, b, c* :     Koeffizienten der Gleichung  *ax+by+c=0*\n\t\n\t\n**Vordefinierte Geraden**\n   \n``x_achse`` : *x* -Achse im Raum \n\n``y_achse`` : ebenso, *y* -Achse\n\n``z_achse`` : ebenso, *z* -Achse  \n\n``x_achse2`` : *x* -Achse in der Ebene\n\n``y_achse2`` : ebenso, *y* -Achse\n\t\t\n    \"\"\"\n\t\t\n    def __new__(cls, *args, **kwargs):  \n\t\t\t\n        if kwargs.get(\"h\") in (1, 2, 3, 4):                         \n            gerade_hilfe(kwargs[\"h\"])\t\t\n            return\t\n\t\t\t\n        try:\t\n\n\t\t     # Erzeugen einer Geraden in R^2\t\n            if is_zahl(args[0]):\n                if len(args) == 2:\n                    if not is_zahl(args[1]):\n                        raise AglaError(\"zwei oder drei Zahlen angeben\")\n                    a = -nsimplify(sympify(args[0]))\n                    b = 1\t\t\t\t\t \n                    c = -nsimplify(sympify(args[1]))\n                elif len(args) == 3:\n                    if not (is_zahl(args[1]) and is_zahl(args[2])):\n                        raise AglaError(\"zwei oder drei Zahlen angeben\")\n                    a = nsimplify(sympify(args[0]))\n                    b = nsimplify(sympify(args[1]))\t\t\t\t\t \n                    c = nsimplify(sympify(args[2]))\n                else:            \n                    raise AglaError(\"zwei oder drei Zahlen angeben\")\n                t = Symbol('t')\t\t\t\t\t\n                return AglaObjekt.__new__(cls, a, b, c, t)\n                 \t\t\t\t\t\t\t \t\n            # Erzeugen einer Geraden in R^3 aus einer Punktmenge mit Parametern\n            if (len(args) == 1 and isinstance(args[0], Vektor)) or \\\n               (len(args) == 2 and isinstance(args[0], Vektor) and not \\\n               isinstance(args[1], Vektor)):\n                p = args[0] \t\n                if not p.free_symbols:\n                    raise AglaError(\"zwei Vektoren oder Vektor mit Parameter(n) angeben\")\n                pars = p.free_symbols\t\t\t\t\n                if len(args) == 2:\t\t\t\t\n                    par\t= args[1]\n                    if not par.free_symbols:\t\t\t\t\t\n                         raise AglaError(\"der angegebene Parameter ist nicht frei\")\n                    if not par in pars:\t\t\t\t\t\n                         raise AglaError(\"der angegebene Parameter ist im Vektor nicht vorhanden\")\n                else:\t\n                    if len(pars) > 1:\t\t\t\t\n                         raise AglaError(\"einen Parameter explizit angeben\")\n                    par = pars.pop()\t\n                stuetz, richt = list(), list() \t\t\t\n                for k in p.komp:\n                    if not k.is_polynomial:\n                        raise AglaError(\"Komponenten müssen Polynome sein\")\n                    if Poly(k, par).degree() > 1:\n                        txt = \"der Parameter darf höchstens in 1. Potenz auftreten\"\n                        raise AglaError(txt)\n                    li = Poly(k, par).all_coeffs()\t\t\t\t\n                    stuetz += [li[-1]]\t\t\t\t\n                    if len(li) == 2:\n                        richt += [li[0]]\n                    else:\n                        richt += [0]\t\n                stuetz = Vektor([nsimplify(k) for k in stuetz])\t\t\t\t\n                richt = Vektor([nsimplify(k) for k in richt])\t\t\t\t\n                return AglaObjekt.__new__(cls, stuetz, richt, par)\n\t   \n\t\t     # Erzeugen einer Geraden in R^3 und R^2 über Stütz- und Richtungsvektor\n            if len(args) < 2 or len(args) > 3:\n                txt = \"Stütz-, Richtungsvektor und evtl. Geradenparameter angeben\"\n                raise AglaError(txt)\t\t\n            if not (isinstance(args[0], Vektor) and isinstance(args[1], Vektor) and\n\t\t         args[0].dim == args[1].dim):\n                raise AglaError(\"zwei Vektoren mit gleicher Dimension angeben\")\n            stuetz = args[0]\t\t\n            richt = args[1]\n            if richt == Vektor(0, 0, 0) or richt == Vektor(0, 0):\n                raise AglaError('der Nullvektor kann nicht Richtungsvektor sein')\t\t\t\n            if len(args) == 3:\n                if isinstance(args[2], Symbol):\n                    parameter = args[2]\t\n                else:\n                    raise AglaError(\"der Bezeichner muss frei sein\")\t\n                if parameter in stuetz.free_symbols | richt.free_symbols:\n                    raise AglaError(\"der Parameter ist in den Vektoren enthalten\")\t\t\t\n            else: \n                parameter = Symbol(\"t\")                   \n            if stuetz.dim in (2, 3):\t\n                sx, sy, rx, ry = [nsimplify(e) for e in (stuetz.x, stuetz.y, \n                                richt.x, richt.y)]\n                if stuetz.dim == 3:\t\n                    sz, rz = nsimplify(stuetz.z), nsimplify(richt.z)\n                    stuetz, richt = Vektor(sx, sy, sz), Vektor(rx, ry, rz)\n                else:\t\t\t\t\t\n                    stuetz, richt = Vektor(sx, sy), Vektor(rx, ry)\n                stuetz = Vektor([nsimplify(k) for k in stuetz.komp])\n                richt = Vektor([nsimplify(k) for k in richt.komp])   \n                return AglaObjekt.__new__(cls, stuetz, richt, parameter)\n            else:\n                txt = \"Geraden sind nur in R^2 und R^3 erzeugbar\"\n                raise AglaError(txt)\n\n        except AglaError as e:\n            print('agla:', str(e))\n            return\t\t\t\n   \n    def __str__(self):  \n        par = self.sch_par\n        if len(par) > 0:\n            ss = str([el for el in par]).replace('[', '')\n            ss = ss.replace(']', '')\n            return \"Geradenschar(\" + ss + \")\"\n        return \"Gerade\"\t\t\t\n\n\t\t\t\t \n# Für Geraden in R^3 und R^2 gemeinsame Eigenschaften + Methoden\n# --------------------------------------------------------------\n\t\t\n    @property\n    def dim(self):              \n        \"\"\"Dimension\"\"\"\n        a = self.args[0]\n        if isinstance(a, Vektor) and a.dim == 3:\n            return 3\n        return 2\n\t\t\n    @property\n    def stuetz(self):              \n        \"\"\"Stützvektor\"\"\"\n        a = self.args[0]\n        if self.dim == 3:\n            return a\n        if isinstance(a, Vektor):\n            return a\n        a, b, c = self.args[:3]\n        if b:\n            return Vektor(0, nsimplify(-c / b))\n        return Vektor(nsimplify(-c / a), 0)\n\t\t\n    auf_pkt = stuetz\n    aufPkt = stuetz\t\t\n            \n    @property\t\n    def richt(self):              \n        \"\"\"Richtungsvektor\"\"\"\n        a = self.args[0]\n        if self.dim == 3:\n            return self.args[1]\n        if isinstance(a, Vektor):\n            return self.args[1]\n        return Vektor(self.args[1], -self.args[0])\n\t\t\t\t\n    @property\t\n    def norm(self):              \n        \"\"\"Normalenvektor\"\"\"\n        if self.dim == 3:\n            print('agla: nur für Geraden in R^2 definiert')\t\t\n            return \n        ri = self.richt\n        return Vektor(-ri.y, ri.x)\n\t\t\n    @property\t\t\t\n    def par(self):              \n        \"\"\"Parameter der Geraden\"\"\"\n        return self.args[-1]\n\n    @property\t\t\t\n    def sch_par(self):              \n        \"\"\"Scharparameter\"\"\"\n        return self.stuetz.free_symbols.union(self.richt.free_symbols)\n\t\n    schPar = sch_par\t\n\t\n    @property\t\t\n    def is_schar(self):              \n        \"\"\"Test auf Schar\"\"\"\n        return len(self.sch_par) == 1\n\t\t\n    isSchar = is_schar\t\t\n\t\t\n    @property\t\t\n    def punkte(self):              \n        \"\"\"Zwei Geradenpunkte\"\"\"\n        return self.stuetz, self.stuetz + self.richt\t\t\n    def punkte_(self, **kwargs): \n        if kwargs.get('h'):\n            print(\"\\nAusgabe: Punkte mit den Parameterwerten 0 und 1\\n\")\n            return\n        return self.pkt(0), self.pkt(1)\t\t\t\n\t\t\n    Punkte = punkte_\n\t\n    @property\t\t\n    def prg(self):              \n        \"\"\"Parametergleichung; nur zur Ausgabe\"\"\"\n        x, y, z = Symbol('x'), Symbol('y'), Symbol('z')\n        if self.dim == 3:\t\t\n            t0 = latex(Vektor(x, y, z)) + latex('=')\n        else:\n            t0 = latex(Vektor(x, y)) + latex('=')\t\t\n        t1 = latex(self.stuetz) + latex('+')\n        t2 = latex(self.par) + '\\,' + latex(self.richt)\n        return display(Math(t0 + t1 + t2)) \n    def prg_(self, *punkt, **kwargs): \n        \"\"\"zugehörige Methode; Auswertung in einem Punkt\"\"\"\n        if kwargs.get('h'):\n            print('\\nAngabe eines Punktes - Auswertung der Gleichung in diesem\\n')\n            return\t\n        try:\t\t\t\n            if len(punkt) != 1:\n                raise AglaError('einen Punkt angeben')\n            punkt = punkt[0]\n            if not isinstance(punkt, Vektor):\n                raise AglaError('einen Punkt angeben')\t\t\t\n            if punkt.dim == self.dim:\n                _r = Symbol('_r')\t\t\t\n                p = self.pkt(_r)\n                ll = loese(p - punkt, _r)\n                if not ll:\n                    lat = latex('\\\\text{die Gleichung ist nicht erfüllt}')\n                    return display(Math(lat))\n                else:\n                    lat = latex('\\\\text{die Gleichung ist erfüllt }') + \\\n                          latex('[') + latex(self.par) + latex('=') + \\\n                          latex(ll[_r]) + latex(']')\t\n                    return display(Math(lat))\n            else:\n                raise AglaError('der Punkt hat nicht die richtige Dimension')\t\t\t\n        except AglaError as e:\n            print('agla:', str(e))\n            return\t\t\t\n\n    Prg = prg_\t\t\t\n\t\t\t\n    gleich = prg\n    gleich_ = prg_\t\n    Gleich = prg_\t\n\t\t\n    @property\t\t\n    def koord(self):              \n        \"\"\"Koordinatengleichung\"\"\"\n        if self.dim == 3:\n            print('agla: nur für Geraden in R^2 definiert')\t\t\n            return\t\t\t\n        x, y = Symbol('x'), Symbol('y')\n        arg = self.args\n        if not isinstance(arg[0], Vektor): \n            a, b, c = arg[:3]\n            gl = Gleichung(a*x + b*y + c, 0)\t\t\n        else:\n            st, ri = arg[:2]\t\t\n            n = Vektor(-ri.y, ri.x)\n            gl = Gleichung(n.x*x + n.y*y - n.sp(st), 0)\t\t\n        return gl\n    def koord_(self, *punkt, **kwargs): \n        \"\"\"zugehörige Methode; Auswertung in einem Punkt\"\"\"\n        if self.dim == 3:\n            print('agla: nur für Geraden in R^2 definiert')\t\t\n            return\t\t\t\n        if kwargs.get('h'):\n            print('\\nAngabe eines Punktes - Auswertung der Gleichung in diesem\\n')\n            return\t\n        try:\t\t\t\n            if len(punkt) != 1:\n                raise AglaError('einen Punkt angeben')\n            punkt = punkt[0]\n            if not isinstance(punkt, Vektor):\n                raise AglaError('einen Punkt angeben')\t\t\t\n            if isinstance(punkt, Vektor) and punkt.dim == self.dim:\n                _r = Symbol('_r')\t\t\t\t\n                p = self.pkt(_r)\n                ll = loese(p - punkt, _r)\n                if not ll:\n                    lat = latex('\\\\text{die Gleichung ist nicht erfüllt}')\n                    return display(Math(lat))\n                else:\n                    lat = latex('\\\\text{die Gleichung ist erfüllt}') \n                    return display(Math(lat))\n            else:\t\t\t\t\t\n                raise AglaError('einen Punkt der Ebene angeben')\n        except AglaError as e:\n            print('agla:', str(e))\n            return\t\t\t\n\n    Koord = koord_\n\t\n    @property\n    def nf(self):\n        \"\"\"Gleichung in Normalenform; nur zur Ausgabe\"\"\"\n        if self.dim != 2:\n            print('agla: nur für Geraden in R^2 definiert')\t\t\n            return\t\t\t\n        x, y = Symbol('x'), Symbol('y')\t\n        lat = latex('\\\\left[') + latex(Vektor(x, y)) +'-' + \\\n\t\t       latex(self.stuetz) + latex('\\\\right]') + latex('\\circ') + \\\n\t\t\t    latex(self.norm) + latex('=') + latex(0) \n        return display(Math(lat))\n    def nf_(self, *punkt, **kwargs): \n        \"\"\"zugehörige Methode; Auswertung in einem Punkt\"\"\"\t\n        if self.dim == 3:\n            print('agla: nur für Geraden in R^2 definiert')\t\t\n            return\t\t\t\n        if kwargs.get('h'):\n            print('\\nAngabe eines Punktes - Auswertung der Gleichung in diesem')\n            print('k = 1 - Ausgabe der Koordinatengleichung\\n')\n            return\t\n        if kwargs.get('k'):\n            return self.koord\t\n        try:\t\t\t\n            if len(punkt) != 1:\n                raise AglaError(\"einen Punkt angeben\")\n            punkt = punkt[0]\n            if isinstance(punkt, Vektor) and punkt.dim == 2:\n                x, y = Symbol('x'), Symbol('y')\n                gl = (Vektor(x, y) -self.stuetz) * self.norm      \n                gl = gl.subs({x:punkt.x, y:punkt.y})\n                if simplify(gl) == 0:\n                    lat = latex('\\\\text{die Gleichung ist erfüllt}')\t\t\t\t\n                    return display(Math(lat))\n                else:\n                    lat = latex('\\\\text{die Gleichung ist nicht erfüllt}')\t\t\t\t\n                    return display(Math(lat))\n                return\n            else:\n                raise AglaError(\"Punkt im Raum angeben\")\n        except AglaError as e:\n            print('agla:', str(e))\n            return\t\t\t\n\n    Nf = nf_\n\t\n    @property\t\t\t\n    def hnf(self):\n        \"\"\"Hessesche Normalenform; nur zur Ausgabe\"\"\"\n        if self.dim != 2:\n            print('agla: nur für Geraden in R^2 definiert')\t\t\n            return\t\t\t\n        x, y = Symbol('x'), Symbol('y')\t\n        lat = latex('\\\\left[') + latex(Vektor(x, y)) +'-' + \\\n\t\t       latex(self.stuetz) + latex('\\\\right]') + latex('\\circ') + \\\n              (latex(1/self.norm.betrag) if self.norm.betrag != 1 else '') \\\n\t\t\t    + latex(self.norm) + latex('=') + latex(0) \n        return display(Math(lat))\n\t\t\n    @property\t\t\n    def fkt(self):              \n        \"\"\"Funktionsgleichung; nur zur Ausgabe\"\"\"\n        if self.dim != 2:\n            print('agla: nur für Geraden in R^2 definiert')\t\t\n            return\t\t\t\n        x, y = Symbol('x'), Symbol('y')\n        arg = self.args\n        if not isinstance(arg[0], Vektor): \n            a, b, c = arg[:3]\n        else:\n            st, ri = self.args[:2]\n            n = Vektor(-ri.y, ri.x)\t\t\t\n            a, b, c = n.x, n.y, - n.sp(st)\n        if not b:\n            print('agla: die Funktionsgleichung ist nicht definiert')\n            return\n        gl = Gleichung(y, nsimplify(expand((-a*x - c) / b)))\t\t\n        return gl\n    def fkt_(self, *punkt, **kwargs): \n        \"\"\"zugehörige Methode; Auswertung in einem Punkt\"\"\"\n        if self.dim != 2:\n            print('agla: nur für Geraden in R^2 definiert')\t\t\n            return\t\t\t\n        if kwargs.get('h'):\n            print('\\nAngabe eines Punktes - Auswertung der Gleichung in diesem\\n')\n            return\t\n        try:\t\t\t\n            if len(punkt) != 1:\n                raise AglaError('einen Punkt angeben')\n            punkt = punkt[0]\n            if not isinstance(punkt, Vektor):\n                raise AglaError('einen Punkt angeben')\t\t\t\n            if isinstance(punkt, Vektor) and punkt.dim == self.dim:\n                _r = Symbol('_r')\t\t\t\n                p = self.pkt(_r)\n                ll = loese(p - punkt, _r)\n                if not ll:\n                    lat = latex('\\\\text{die Gleichung ist nicht erfüllt}')\n                    return display(Math(lat))\n                else:\n                    lat = latex('\\\\text{die Gleichung ist erfüllt}') \n                    return display(Math(lat))\n            else:\t\t\t\t\t\n                raise AglaError('einen Punkt der Ebene angeben')\n        except AglaError as e:\n            print('agla:', str(e))\n            return\n\t\t\t\n    Fkt = fkt_\n\t\n    @property\n    def anstieg(self):\n        \"\"\"Anstieg\"\"\"\t\n        if self.dim != 2:\n            print('agla: nur für Geraden in R^2 definiert')\t\t\n            return\t\t\t\n        args = self.args\n        m = None\n        if not isinstance(args[0], Vektor):\t\n            if args[1]:\n                m = -args[0] / args[1]\t\t\t\n                try:\t\t\t\t\t\n                    m = nsimplify(m)\n                except RecursionError:\n                    pass\t\t\t\t\t\n        else:\t\n            ri = args[1]\t\t\n            if ri.x:\n                m = ri.y / ri.x\t\t\t\n                try:\t\t\t\t\t\n                    m = nsimplify(m)\n                except RecursionError:\n                    pass\t\t\t\t\t\n        if m is not None:\n            return m\t\t\n        print('agla: der Anstieg ist nicht definiert')\n\t\t\n    m = anstieg\t\t\n\t\t\n\t\t\n    @property\n    def y_abschn(self):\n        \"\"\"Abschnitt auf der *y* -Achse\"\"\"\t\n        if self.dim != 2:\n            print('agla: nur für Geraden in R^2 definiert')\t\t\n            return\t\t\t\n        args = self.args\n        n = None\n        if not isinstance(args[0], Vektor):\t\t\n            if args[1]:\n                n = -args[2] / args[1]\t\t\t\n                try:\t\t\t\t\t\n                    n = nsimplify(n)\n                except RecursionError:\n                    pass\t\t\t\t\t\n        else:\n            st, ri = args[:2]\t\t\n            if ri.x:\n                n = st.y - st.x / ri.x * ri.y\n                try:\t\t\t\t\t\n                    n = nsimplify(n)\n                except RecursionError:\n                    pass\t\t\t\t\t\n        if n is not None:\n            return n\t\t\n        print('agla: der Abschnitt auf der y-Achse ist nicht definiert')\n\t\t\n    n = yAbschn = y_abschn\n\t\n    @property\n    def aagl(self):\n        \"\"\"Achsenabschnittsgleichung\"\"\"\n        if self.dim != 2:\n            print('agla: nur für Geraden in R^2 definiert')\t\t\n            return\t\t\t\n        args = self.args\n        if args[2]:\n            x, y = Symbol('x'), Symbol('y')\t\t\t\n        args = self.args\n        gl = None\n        if not isinstance(args[0], Vektor): \n            if args[2]:\t\t\n                a = -args[0] / args[2]\n                b = -args[1] / args[2]\t\n                try:\n                    a, b = nsimplify(a), nsimplify(b)\t\t\n                except RecursionError:\n                    pass\t\t\t\t\t\n                gl = Gleichung(a*x + b*y, 1) \n        else:\n            st, ri = args[:2]\t\t\n            n = Vektor(-ri.y, ri.x)\n            if n.sp(st):\t\t\n                a = n.x / n.sp(st)\t\t\n                b = n.y / n.sp(st)\t\t\t\n                try:\n                    a, b = nsimplify(a), nsimplify(b)\t\t\n                except RecursionError:\n                    pass\t\t\t\t\t\n                gl = Gleichung(a*x + b*y, 1) \n        if gl is None:          \t\t\t\n            display(Math('\\\\text{die Achsenabschnittsgleichung ist nicht definiert}'))\n        return gl\t\t\t\n\t\n\t\t\n    @property\t\t\n    def spur_xy(self):\n        \"\"\"Spur in der *xy* - Ebene\"\"\"\t\n        if self.dim != 3:\n            print('agla: nur für Geraden in R^3 definiert')\t\t\n            return\t\t\n        xy_ebene = importlib.import_module('agla.lib.objekte.ebene').xy_ebene\t\n        return self.schnitt(xy_ebene)\n\t\t\n    spurXY = spur_xy\t\t\n\t\t\n    @property\t\t\n    def spur_xz(self):\n        \"\"\"Spur in der *xz* - Ebene\"\"\"\t\n        if self.dim != 3:\n            print('agla: nur für Geraden in R^3 definiert')\t\t\n            return\t\t\n        xz_ebene = importlib.import_module('agla.lib.objekte.ebene').xz_ebene\t\n        return self.schnitt(xz_ebene)\n\n    spurXZ = spur_xz\t\t\n\t\t\n    @property\t\t\t\t\n    def spur_yz(self):\n        \"\"\"Spur in der *yz* - SEbene\"\"\"\t\n        if self.dim != 3:\n            print('agla: nur für Geraden in R^3 definiert')\t\t\n            return\t\t\n        yz_ebene = importlib.import_module('agla.lib.objekte.ebene').yz_ebene\t\n        return self.schnitt(yz_ebene)  \t\t\n\t\t\n    spurYZ = spur_yz\t\t\n\t\t\t\n    def sch_el(self, *wert, **kwargs):\n        \"\"\"Element einer Schar; für einen Parameter\"\"\"\n        try:\n\t\t\n            if not self.is_schar or len(self.sch_par) > 1:\n                raise AglaError(\"keine Schar mit einem Parameter\")\t\t\t\n\t\t\n            if kwargs.get('h'):\n                print(\"\\nElement einer Schar von Geraden\\n\")\t\t\n                print(\"Aufruf   gerade . sch_el( wert )\\n\")\t\t                     \n                print(\"             gerade    Gerade\")\n                print(\"             wert      Wert des Scharparameters\")\t\t\t\n                print(\"\\nEs ist nur ein Scharparameter zugelassen\\n\")    \n                return \n\t\t\t\n            if not wert or len(wert) != 1:\n                raise AglaError(\"einen Wert für den Scharparameter angeben\")\n        except AglaError as e:\n            print('agla:', str(e))\n            return\n\t\t\t\n        p = Tuple(*self.sch_par)[0]\n        wert = sympify(*wert)\n        if not is_zahl(wert):\n            print('agla: für den Scharparameter Zahl oder freien Parameter \\\n\t\t\t         angeben')\t\n            return\t\t\n        stuetz = Vektor([k.subs(p, wert) for k in self.stuetz.komp])\n        richt = Vektor([k.subs(p, wert) for k in self.richt.komp])\t\t\n        return Gerade(stuetz, richt, self.par)\t\t\t\n\t\t\n    schEl = sch_el\n\t\n\t\t\n    def abstand(self, *objekt, **kwargs):\t\n        \"\"\"Abstand zu einem anderen Objekt\"\"\"\n\t\t\n        if kwargs.get('h'):\n            print(\"\\nAbstand der Geraden zu einem anderen Objekt\\n\")\t\t\n            print(\"Aufruf   gerade . abstand( objekt )\\n\")\t\t                     \n            print(\"             gerade    Gerade\")\n            print(\"             objekt    Punkt, Gerade, Ebene, Kugel  (im Raum R^3)\")\t\t\n            print(\"                       Punkt, Gerade  (in der Ebene R^2)\\n\")\t\t\n            print(\"Rückgabe 0, wenn gerade und objekt sich schneiden\\n\")\t\t\n            print(\"Zusatz       d=n   Dezimaldarstellung\")\n            print(\"                   n - Anzahl der Nachkomma-/Stellen\\n\")\n            return\n\t\n        if len(objekt) != 1:\n            print('agla: ein Objekt angeben')\n            return\n\t\t\t\n        objekt = objekt[0]\n        if\t self.dim == 3:\n            Ebene = importlib.import_module('agla.lib.objekte.ebene').Ebene\t\n            Kugel = importlib.import_module('agla.lib.objekte.kugel').Kugel\n            if not isinstance(objekt, (Vektor, Gerade, Ebene, Kugel)):\t\t\t\n                print('agla: Punkt, Gerade, Ebene oder Kugel angeben')\n                return\t\t\t\n\t\t\t\n            if isinstance(objekt, Vektor):   # Gerade - Punkt\n                q = self.stuetz\n                m = self.richt.einh_vekt\n                wert = sqrt(((objekt - q) * (objekt - q) - \\\n                                        (m * (objekt - q))**2))\n            elif isinstance(objekt, Gerade):   # Gerade - Gerade\n                if objekt.dim == 3:\n                    if objekt.richt.kollinear(self.richt):     \n                        if objekt.stuetz.abstand(self) == 0:   \n                            wert = 0\n                        else:                                \n                            wert = objekt.stuetz.abstand(self)\n                    else:\n                        if objekt.schnitt(self):\n                            wert = 0\n                        else: \n                            e = Ebene(objekt.stuetz, objekt.richt, self.richt)\n                            wert = self.stuetz.abstand(e)\t\n                else:\n                    print('agla: die Gerade hat nicht die richtige Dimension')\n                    return\t\t\t\t\t\n            else:\n                wert = objekt.abstand(self)\n\t\t\t\t\n        if self.dim == 2:\n            if not isinstance(objekt, (Vektor, Gerade)):\n                print('agla: Punkt oder Gerade angeben')\n                return\t\t\t\t\n            st, ri = self.stuetz, self.richt\n            st, ri = Vektor(st.x, st.y, 0), Vektor(ri.x, ri.y, 0)\n            g3 = Gerade(st, ri)\t\t\t\n            if isinstance(objekt, Vektor):\n                o3 = Vektor(objekt.x, objekt.y, 0)\t\n            else:\n                if objekt.dim != 2:\t\t\t\n                    print('agla: die Gerade hat nicht die richtige Dimension')\n                    return\t\t\t\t\t\n                st, ri = objekt.stuetz, objekt.richt\n                st, ri = Vektor(st.x, st.y, 0), Vektor(ri.x, ri.y, 0)\n                o3 = Gerade(st, ri)\n            wert = g3.abstand(o3)\t\t\t\t\n                \t\t\t\n        d = kwargs.get('d')\n        if not isinstance(d, (Integer, int)) or d < 0:\n            return wert\n        return wert_ausgabe(wert, d)\n\t\t\t\n\t\t\t\n    def bild(self, *abb, **kwargs):\t\n        \"\"\"Bild bei einer Abbildung\"\"\"\n\t\t\n        if kwargs.get('h'):\n            print(\"\\nBildgerade bei einer Abbildung\\n\")\t\t\n            print(\"Aufruf   gerade . bild( abb )\\n\")\t\t                     \n            print(\"             gerade    Gerade\")\n            print(\"             abb       Abbildung\\n\")\t\t\n            return\n\t\n        try:\t\n            if len(abb) != 1:\n                raise AglaError(\"eine Abbildung angeben\")\n            abb = abb[0]\n            Abbildung = importlib.import_module('agla.lib.objekte.abbildung').Abbildung\t\n            if not isinstance(abb, Abbildung):\n                raise AglaError(\"eine Abbildung angeben\")\t\t\t\n            if abb.dim != self.dim:\n                raise AglaError(\"die Dimensionen sind unterschiedlich\")\t\t\n        except AglaError as e:\n            print('agla:', str(e))\n            return\n        p, q = self.punkte\n        p1 = abb.matrix*p + abb.versch\n        q1 = abb.matrix*q + abb.versch\n        if p1 != q1:\n            return Gerade(p1, Vektor(p1, q1))\n        else:\n            return p1\t\t\t\t\t\n\t\t\n\n    def graf(self, spez, **kwargs):                       \n        \"\"\"Grafikelement für Gerade\"\"\"\t\n        if self.dim == 3:\n            if UMG.grafik_3d == 'mayavi':\n                return self.mayavi(spez, **kwargs)\n            else:\t\t\t\t\n                return self.vispy(spez, **kwargs)\n        else:\n            return self.graf2(spez, **kwargs)\n  \t\t\t\n    def mayavi(self, spez, **kwargs):                       \n        \"\"\"Grafikelement für Gerade in R^3 mit mayavi\"\"\"\t\t\t\n\t\t\t\t\n        lin_farbe = UMG._default_lin_farbe if spez[1] == 'default' else spez[1]\t\t\n        lin_staerke = UMG._default_lin_staerke if spez[2] == 'default' else \\\n\t\t              spez[2][1]\n\t\t\t\t\t  \n        anim = False\t\t\t\n        if spez[3]:\n            anim = True            \n            aber = spez[3]\t\n\t\t\t\n        xl, xr, yl, yr, zl, zr = [x for x in list(UMG._sicht_box)]\t\t\t\t\n        def par_werte(gerade):\n            Ebene = importlib.import_module('agla.lib.objekte.ebene').Ebene\t\n            eb = [ Ebene(1,0,0,-xl), Ebene(1,0,0,-xr), Ebene(0,1,0,-yl), \n\t\t            Ebene(0,1,0,-yr), Ebene(0,0,1,-zl), Ebene(0,0,1,-zr) ]\n            x, y, z, t = Symbol(\"x\"), Symbol(\"y\"), Symbol(\"z\"), Symbol('t')\n            p = gerade.pkt(t)\n            li = []\n            for e in eb:\n                gl = e.koord_(Vektor(0,0,0), ausgabe=False).subs(x, p.x).\\\n                        subs(y, p.y).subs(z, p.z)\n                if  gl.lhs.has(t):\n                    li1 = solve(gl.lhs)\n                    li += [[li1[0], gerade.pkt(li1[0])]]\n            li1 = []\t\t\t\t\n            for el in li:\n                p = el[1].dez\n                if (xl<=p.x<=xr) and (yl<=p.y<=yr) and (zl<=p.z<=zr):\n                    li1 += [el[0]]\n            tmin, tmax = Min(*li1), Max(*li1)\n            return tmin, tmax\n\t\t\t\n        if not anim:\t\t\t\n            tmin, tmax = par_werte(self)\n            p, q = self.pkt(tmin), self.pkt(tmax)\n            x, y, z = [float(p.x), float(q.x)], [float(p.y), float(q.y)], \\\n                     [float(p.z), float(q.z)] \n            return mlab.plot3d(x, y, z, line_width=lin_staerke, \n                            color=lin_farbe, tube_radius=None)      \n        else:\n\t\t\n            # Da mlab.plot3d(..., extent=...) nicht funktioniert, müssen für jeden \n            # Wert aus dem Parameterbereich die Schnittpunkte der Geraden mit den \n            # Ebenen, die die Sichtbox begrenzen, berechnet werden\n\t\t\t\n            print('agla: lange Rechenzeit')\n\t\t\t\n            if len(aber) == 3:\n                N = aber[2]\n            else:\n                N = 20\t\t\t\t\t\t\n            aa = np.linspace(float(aber[0]), float(aber[1]), N)  \n            xa, ya, za = [], [], []\n            x, y, z, b_, t = symbols('x y z b_ t')\t\t\t\n            gg = self.sch_el(b_)\t\t\t\n            xx, yy, zz = gg.pkt(t).komp\n            xs, ys, zs = repr(xx), repr(yy), repr(zz)\n\n            from numpy import sin, cos, tan, abs, log, arcsin, arccos, arctan, \\\n               sinh, cosh, tanh, arcsinh, arccosh, arctanh, sqrt, exp, pi\n            tab = _funkt_sympy2numpy \t\t\t   \n            for tt in tab:\n                if tt in xs:\t\t\t\n                    xs = xs.replace(tt, tab[tt]) \n                if tt in ys:\t\t\t\t\n                    ys = ys.replace(tt, tab[tt]) \n                if tt in zs:\t\t\t\t\t\n                    zs = zs.replace(tt, tab[tt])\n            ebenen = [x-xl, x-xr, y-yl, y-yr, z-zl, z-zr]\n            i, tol = 0, 1e-6\n            typ = (int, Integer, float, Float)\t\t\t\n            for bb in aa:\n                bb = '(' + str(bb) + ')'\n                sx = eval(xs.replace('b_', bb))\n                sy = eval(ys.replace('b_', bb))\n                sz = eval(zs.replace('b_', bb))\n                tt = []\n                for e in ebenen:\n                    gl = e.subs([(x, sx), (y, sy), (z, sz)])\n                    L = loese(gl)\n                    if L:\t\t\t\t\t\n                        tt += [L[t]]\t\t\t\n                tt = [s for s in tt if \n                     xl-tol<=(sx if isinstance(sx, typ) else sx.subs(t, s))<=\n                                                             xr+tol and \n\t                  yl-tol<=(sy if isinstance(sy, typ) else sy.subs(t, s))<=\n                                                             yr+tol and \n                     zl-tol<=(sz if isinstance(sz, typ) else sz.subs(t, s))<=\n                                                                zr+tol]\t\n                if not tt:\n                    xa += [[0, 0]]\t\t\t\t\n                    ya += [[0, 0]]\t\t\t\t\n                    za += [[0, 0]]\n                    i += 1\t\t\t\t\t \t\t\t\t\t\n                    continue\t\t\t\t\n                tmin = Min(*tt)\n                tmax = Max(*tt)\t\t\n                if isinstance(sx, typ):\t\t\n                    xa += [[float(sx), float(sx)]]\n                else:\t\t\t\t\t\n                    xa += [[float(sx.subs(t, tmin)), float(sx.subs(t, tmax))]]\n                if isinstance(sy, typ):\t\t\n                    ya += [[float(sy), float(sy)]]\n                else:\t\t\t\t\t \n                    ya += [[float(sy.subs(t, tmin)), float(sy.subs(t, tmax))]]\n                if isinstance(sz, typ):\t\t\n                    za += [[float(sz), float(sz)]]\n                else:\t\t\t\t\t\n                    za += [[float(sz.subs(t, tmin)), float(sz.subs(t, tmax))]]\n            plt = mlab.plot3d(xa[0], ya[0], za[0], line_width=lin_staerke, \n                     color=lin_farbe, tube_radius=None) \n            return plt, (xa[1:], ya[1:], za[1:]), N-1\t\n\t\t\t\t\t \t\t\n\t\t\t\t\t\t\t\n    def vispy(self, spez, **kwargs):                       \n        \"\"\"Grafikelement für Gerade in R^3 mit vispy\"\"\"\t\n\t\t\n        pass\t\t\n\t\t\t\t\n\t\t\t\n    def graf2(self, spez, **kwargs):                       \n        \"\"\"Grafikelement für Gerade in R^2\"\"\"\t\n\t\t\t\t\t\t\n        lin_farbe = UMG._default_lin_farbe2 if spez[1] == 'default' else \\\n\t\t            spez[1]\t\t\n        lin_staerke = UMG._default_lin_staerke2 if spez[2] == 'default' \\\n\t\t              else spez[2][3]\n\t\t\n        anim = False\t\t\t\n        if spez[3]:\n            anim = True            \n            aber = spez[3]\t\t\t\n\t\t\n        if not anim:\t\t\t\n            tmin, tmax = -1000, 1000\n            p, q = self.pkt(tmin), self.pkt(tmax)\n            x, y = [float(p.x), float(q.x)], [float(p.y), float(q.y)]\n            return plt.plot(x, y, linewidth=lin_staerke, \n                            color=lin_farbe)      \t\n\t\t\n\t\n    def schnitt(self, *objekt, **kwargs):\n        \"\"\"\"Schnitt mit anderen Objekten\"\"\"\n\t\t\t\t\n        if kwargs.get('h'):\n            print(\"\\nSchnitt der Geraden mit einem anderen Objekt\\n\")\t\t\n            print(\"Aufruf   gerade . schnitt( objekt )\\n\")\t\t                     \n            print(\"             gerade    Gerade\")\n            print(\"             objekt    Punkt, Gerade, Ebene, Kugel, Strecke, \")\n            print(\"                       Dreieck, Viereck \" + \\\n\t\t\t       \"im Raum R^3)\")\n            print(\"                       Punkt, Gerade, Strecke, Kreis \")\n            print(\"                                              \" + \\\n\t\t\t      \"in der Ebene R^2\")\n            print(\"Zusatz       l=1   Lageinformationen\\n\")\t\t\t\n            return\n\t\t\t\n        Strecke = importlib.import_module('agla.lib.objekte.strecke').Strecke\t\n\t\t\n        if self.dim == 3: \t\n\t\t\n            Ebene = importlib.import_module('agla.lib.objekte.ebene').Ebene\t\n            Kugel = importlib.import_module('agla.lib.objekte.kugel').Kugel\n            Dreieck = importlib.import_module('agla.lib.objekte.dreieck').Dreieck\t\n            Viereck = importlib.import_module('agla.lib.objekte.viereck').Viereck\t\n\t\t\t\n            try:\t\n                if not objekt:\n                    raise AglaError(\"ein Objekt angeben\")\n                if len(objekt) != 1:\n                    raise AglaError('ein Objekt angeben')\t\t\t\t\t\n                objekt = objekt[0]\t\n                if not isinstance(objekt, (Vektor, Gerade, Ebene, Kugel, \\\n\t\t\t\t         Strecke, Dreieck, Viereck)):\n                    raise AglaError(\"Vektor, Gerade, Ebene, Kugel, \" + \\\n\t\t\t\t\t         \"Strecke, Dreieck oder Viereck angeben\")\n                if self.dim != objekt.dim:\n                    raise AglaError(\"die Objekte haben unterschiedliche Dimension\")      \t\t\t\t\n            except AglaError as e:\t\t\n                print('agla:', str(e))\n                return\n            if isinstance(objekt, Vektor):\n                t = Symbol('t')\t\t\t\t\n                L = loese(self.pkt(t) - objekt) \t\t\t\t\n                if L:\n                    if kwargs.get('l'):\n                        lat = latex('\\\\text{der Punkt liegt auf der Geraden}')\t\t\n                        display(Math(lat))\t\t\t\t\t\n                        return \n                    return objekt\n                if kwargs.get('l'):\n                    lat = latex('\\\\text{der Punkt liegt nicht auf der ' + \\\n\t\t\t\t\t'Geraden}')\t\t\n                    display(Math(lat))\t\t\t\t\t\n                    return \n                return set()\n            elif isinstance(objekt, Gerade):\n                r, s = Symbol(\"r\"), Symbol(\"s\")\n                p, q = objekt.pkt(r), self.pkt(s)\n                try:\n                    di = solve([p.x - q.x, p.y -  q.y, p.z - q.z], [r, s])\n                except RuntimeError:\n                    from sympy import N\n                    di = solve([N(p.x - q.x), N(p.y -  q.y), \\\n                               N(p.z - q.z)], [r, s])\t\t\t\t\n                if not di:                   \n                    if kwargs.get('l'):\n                        if kollinear(self.richt, objekt.richt):\n                            zusatz = '\\\\text{parallel}'\n                        else:\n                            zusatz = '\\\\text{windschief}'\n                        lat = latex('\\\\text{die Geraden schneiden sich }') + \\\n\t\t\t\t\t             latex('\\\\text{nicht, sie sind }' + zusatz)\t\t\t\t\t\t\n                        display(Math(lat))\n                        return\t\t\t\t\t\n                    return set()             \n                elif len(di)  == 1:\n                    if kwargs.get('l'):\n                        lat = latex('\\\\text{die Geraden sind identisch}')\n                        display(Math(lat))\n                        return\t\t\t\t\t\n                    return self\n                if kwargs.get('l'):\n                    lat = latex('\\\\text{die Geraden schneiden sich im }') + \\\n                          latex('\\\\text{Punkt}')\n                    pp = objekt.pkt(di[r])\n                    lat1 = pp.punkt_ausg_(s=1)\n                    lat2 = latex('[\\:') + latex(self.par) + latex('=') + \\\n\t\t\t\t\t\t      latex(di[s]) + latex('\\:]')\n                    display(Math(lat + lat1 + '\\:\\:' + lat2))\n                    return\t\t\t\t\n                return objekt.pkt(di[r])       \n            else:\n                if kwargs.get('l'):\n                    return objekt.schnitt(self, l=1)\t\t\n                return objekt.schnitt(self)\t\t\n\t\t\t\t\n        elif self.dim == 2: \n           \t\t\n            Kreis = importlib.import_module('agla.lib.objekte.kreis').Kreis\t\n            st, ri = self.stuetz, self.richt\t\n            g3 = Gerade(Vektor(st.x, st.y, 0), Vektor(ri.x, ri.y, 0))\t\t\n            try:\t\n                if not objekt:\n                    raise AglaError(\"Vektor, Gerade, Strecke oder Kreis angeben\")\n                if len(objekt) != 1:\n                    raise AglaError('ein Objekt angeben')\t\t\t\t\t\n                objekt = objekt[0]\t\n                if mit_param(self) or mit_param(objekt) and isinstance(objekt, \n                    (Strecke, Kreis)):\n                    print('agla: nicht implementiert (Parameter)')\n                    return\t\t\t\t\n                if not isinstance(objekt, (Vektor, Gerade, Strecke, Kreis)):\n                    raise AglaError(\"Vektor, Gerade, Strecke  oder Kreis angeben\")\t\t     \n                if self.dim != objekt.dim:\n                    raise AglaError(\"die Objekte haben unterschiedliche Dimension\")      \t\t\t\t\n            except AglaError as e:\t\t\n                print('agla:  ', str(e))\n                return\n            if isinstance(objekt, Vektor):\n                if objekt.dim != 2:\n                    print(\"agla: der Vektor hat nicht die richtige Dimension\")\n                    return\t\t\t\t\t\n                o3 = Vektor(objekt.x, objekt.y, 0)\n                ss = g3.schnitt(o3)\t\t\n                if ss:\n                    if kwargs.get('l'):\n                        lat = latex('\\\\text{der Punkt liegt auf der Geraden}')\t\t\n                        display(Math(lat))\t\t\t\t\t\n                        return \t\t\t\t\n                    return Vektor(ss.x, ss.y)\n                if kwargs.get('l'):\n                    lat = latex('\\\\text{der Punkt liegt nicht auf }' + \\\n                               '\\\\text{der Geraden}')\t\t\n                    display(Math(lat))\t\t\t\t\t\n                    return \t\t\t\t\n                return set()\t\n            elif isinstance(objekt, Gerade):\n                if objekt.dim != 2:\n                    print(\"agla: die Gerade hat nicht die richtige Dimension\")\n                    return\t\n                st, ri = objekt.stuetz, objekt.richt\t\n                st, ri = Vektor(st.x, st.y, 0), Vektor(ri.x, ri.y, 0)                \t\t\t\t\t            \n                o3 = Gerade(st, ri)  \n                ss = g3.schnitt(o3)   \n                if isinstance(ss, Vektor):\n                    ss2 = Vektor(ss.x, ss.y)\t\t\t\t\n                    if kwargs.get('l'):\n                        lat = latex('\\\\text{die Geraden schneiden sich }'+ \\\n                             '\\\\text{im Punkt}')\t\t   \n                        lat1 = ss2.punkt_ausg_(s=1)\n                        display(Math(lat + lat1))\t\t\t\t\t\n                        return \t\t\t\t\t\t\t\t\n                    return ss2\n                elif isinstance(ss, Gerade):\n                    if kwargs.get('l'):\n                        lat = latex('\\\\text{die Geraden sind identisch}')\t\t\n                        display(Math(lat))\t\t\t\t\t\n                        return \t\t\t\t\t\t\t\t\n                    return self\n                if kwargs.get('l'):\n                    lat = latex('\\\\text{die Geraden schneiden sich nicht}')\t\t\n                    display(Math(lat))\t\t\t\t\t\n                    return \t\t\t\t\t\t\t\t\n                return set()\t\t\t\t\t\n            elif isinstance(objekt, Strecke):\n                if objekt.dim != 2:\n                    print(\"agla: die Strecke hat nicht die richtige Dimension\")\n                    return\t\n                p1, p2 = objekt.punkte\n                p1, p2 = Vektor(p1.x, p1.y, 0), Vektor(p2.x, p2.y, 0)\n                o3 = Strecke(p1, p2)\n                ss = g3.schnitt(o3)\n                if isinstance(ss, Vektor):\n                    if kwargs.get('l'):\n                        lat = latex('\\\\text{die Strecke schneidet die }' + \\\n                             '\\\\text{Gerade in einem Punkt}')\t\t\n                        display(Math(lat))\t\t\t\t\t\n                        return \t\t\t\t\t\t\t\t\n                    return Vektor(ss.x, ss.y)\n                elif isinstance(ss, Strecke):\n                    if kwargs.get('l'):\n                        lat = latex('\\\\text{die Strecke liegt auf der }' + \\\n                             '\\\\text{Geraden}')\t\t\n                        display(Math(lat))\t\t\t\t\t\n                        return \t\t\t\t\t\t\t\t\n                    p1, p2 = ss.punkte\n                    p1, p2 = Vektor(p1.x, p1.y), Vektor(p2.x, p2.y)\t\t\t\t\t\n                    return Strecke(p1, p2)\n                if kwargs.get('l'):\n                    lat = latex('\\\\text{die Strecke schneidet die }' + \\\n                         '\\\\text{Gerade nicht}')\t\t\n                    display(Math(lat))\t\t\t\t\t\n                    return \t\t\t\t\t\t\t\t\n                return set()\t\t\t\t\t\n            elif isinstance(objekt, Kreis):\n                if kwargs.get('l'):\n                    return objekt.schnitt(self, l=1)\t\t\t\t\n                return objekt.schnitt(self)\n                \t\t\t\t\n\t\t\t\t\n    def winkel(self, *objekt, **kwargs):\n        \"\"\"Winkel mit einem anderen Objekt\"\"\"\n\t\t\t\t\t\n        if kwargs.get('h'):\n            print(\"\\nWinkel der Geraden mit einem anderen Objekt (in Grad)\\n\")\t\t\n            print(\"Aufruf   gerade . winkel( objekt )\\n\")\t\t                     \n            print(\"             gerade    Gerade\")\n            print(\"             objekt    Vektor, Gerade, Ebene  (im Raum R^3)\")\n            print(\"                       Vektor, Gerade  (in der Ebene R^2)\\n\")\n            print(\"Bei objekt=Gerade Rückgabe des Winkels zwischen den beiden\")\n            print(\"Richtungsvektoren (unabhängig von der Lage)\\n\")\n            print(\"Zusatz       d=n   Dezimaldarstellung\")\n            print(\"                   n - Anzahl der Nachkomma-/Stellen\\n\")\n            return \n\t\t\n        if len(objekt) != 1:\n            print(\"agla: ein Objekt angeben\")\n            return\t\t\t\n        objekt = objekt[0]\n        if objekt == Vektor(0, 0, 0) or objekt == Vektor(0, 0):\n            print('agla: der Winkel ist nicht definiert (Nullvektor)')\n            return\n\t\t\t\n        if self.dim == 3:\n            Ebene = importlib.import_module('agla.lib.objekte.ebene').Ebene\t\n            if isinstance(objekt, Vektor):\t\n                wi = self.richt.winkel(objekt)\n            elif isinstance(objekt, Gerade):\n                wi = self.richt.winkel(objekt.richt)\n            elif isinstance(objekt, Ebene):\n                wi = objekt.winkel(self)\t\t\n            else:\n                print('agla: Vektor, Gerade oder Ebene angeben')\n                return\n            if not mit_param(wi):\t\t\t\t\n                if wi > 90:\n                    wi = 180 - wi\t\t\t\t\n        else:\n            if not isinstance(objekt, (Vektor, Gerade)):\n                print('agla: Vektor oder Gerade angeben')\n                return\t\t\t\n            if objekt.dim != 2:\n                print('agla: der Vektor bzw. die Gerade hat nicht die ' + \\\n\t\t\t\t        'richtige Dimension')\n                return\n            st, ri = self.stuetz, self.richt\n            st, ri = Vektor(st.x, st.y, 0), Vektor(ri.x, ri.y, 0)\n            g3 = Gerade(st, ri)\n            if isinstance(objekt, Vektor):\n                o3 = Vektor(objekt.x, objekt.y, 0)\n            else:\n                st, ri = objekt.stuetz, objekt.richt\n                st, ri = Vektor(st.x, st.y, 0), Vektor(ri.x, ri.y, 0)\n                o3 = Gerade(st, ri)\t\t\t\n            wi = g3.winkel(o3)\n\t\t\t\n        d = kwargs.get('d')\n        if not isinstance(d, (Integer, int)) or d < 0:\n            return wi\n        return wert_ausgabe(wi, d)\n\t\t\n\t\t\n    def proj(self, *ebene, **kwargs):\t\n        \"\"\"Projektion auf eine Ebene\"\"\"\n\t\t\n        if self.dim != 3:\n            print('agla: nur für Geraden in R^3 definiert')\t\t\n            return\t\t\t\n\t\t\n        if kwargs.get('h'):\n            print(\"\\nProjektion der Geraden auf eine Ebene\\n\")\t\t\n            print(\"Aufruf   gerade . proj( ebene )\\n\")\t\t                     \n            print(\"             gerade    Gerade\")\n            print(\"             ebene     Ebene\\n\")\n            return\n\t\n        if len(ebene) != 1:\n            print(\"agla: eine Ebene angeben\")\n            return\t\t\t\n        ebene = ebene[0]\n        p = self.schnitt(ebene)\n        if p:\n            if isinstance(p, Gerade):\n                return self\n            if orthogonal(self, ebene):\n                return p\n            q = self.punkte[0]\n            if q == p:\n                q = self.punkte[1]\n            g = Gerade(q, ebene.norm)\n            s = g.schnitt(ebene)\n            return Gerade(p, Vektor(p, s))\n        elif self.abstand(ebene) == 0:\n            return self\n        p, q = self.punkte[0], self.punkte[1]\n        g1, g2 = Gerade(p, ebene.norm), Gerade(q, ebene.norm)\n        s1, s2 = g1.schnitt(ebene), g2.schnitt(ebene)\t\n        return Gerade(s1, Vektor(s1, s2))\n\n\t\n    def pkt(self, *wert, **kwargs):\n        \"\"\"Geradenpunkt\"\"\"\n\t\t\n        if kwargs.get('h'):\n            print(\"\\nPunkt der Geraden\\n\")\t\t\n            print(\"Aufruf    gerade . pkt( /[ wert ] )\\n\")\t\t                     \n            print(\"              gerade   Gerade\")\n            print(\"              wert     Wert des Geradenparameters\\n\")\n            print(\"Rückgabe      bei Angabe eines Parameterwertes:\") \n            print(\"              Geradenpunkt, der zu diesem Wert gehört\")\n            print(\"              bei leerer Argumentliste oder freiem \" + \\\n\t\t\t       \"Bezeichner:\") \n            print(\"              allgemeiner Punkt der Geraden\\n\") \t\t\t\n            return\n\n        if not wert:\n            return self.stuetz + self.richt * self.par\n        if len(wert) == 1:\n             pw = sympify(wert[0])\n             if not is_zahl(pw):\n                 print('agla: Zahlenwert oder freien Bezeichner angeben')\n                 return\t\t\t\n             return self.stuetz + self.richt * pw\t\t\t \n        print(\"agla: einen Parameterwert angeben\")\n        return\t\t\n\t\t\n\t\t    \n    def normale(self, *arg, **kwargs):\n        \"\"\"Normale in einem Geradenpunkt\"\"\"\n\t\t\n        if self.dim != 2:\n            print('agla: nur für Geraden in R^2 definiert')\t\t\n            return\n\t\t\t\n        if kwargs.get('h'):\n            print(\"\\nNormale in einem Geradenpunkt\\n\")\t\t\n            print(\"Aufruf    gerade . normale( /[ punkt | wert ] )\\n\")\t\t                     \n            print(\"              gerade   Gerade\")\n            print(\"              punkt    Geradenpunkt\")\n            print(\"              wert     Wert des Geradenparameters\\n\")\n            print(\"Rückgabe      bei Angabe eines Punktes oder Parameterwertes:\") \n            print(\"              Normale im (zugehörigen) Geradenpunkt\")\n            print(\"              bei leerer Argumentliste oder freiem \" + \\\n\t\t\t       \"Bezeichner:\") \n            print(\"              Normale im allgemeinen Geradenpunkt\\n\") \t\t\t\n            return\n\t\t\t\n        if len(arg) > 1:\n            raise AglaError('nur ein Argument angeben')\n            return\t\t\t\n        if arg:\n            arg = arg[0] \n        else:\n            arg = None\t\t\t\t\t\n        if isinstance(arg, Vektor):\n            if arg.dim != 2:\n                raise AglaError('Punkt in der Ebene angeben')\n                return\t\t\t\n            if not self.schnitt(arg):\n                raise AglaError('der Punkt liegt nicht auf der Geraden')\n                return\t\t\t\t\t\t\n            p = arg\n        else:\t\t\t\n            if arg:\t\t\t\n                pw = sympify(arg)\n                if not is_zahl(pw):\n                    print(\"agla: einen Zahlenwert angeben\")\n                    return\t\n                pw = nsimplify(pw)\t\t\t\t \n                p = self.pkt(pw)\n            else:\n                p = self.pkt(self.par)\t\t\n        ri = self.richt\n        n = Vektor(-ri.y, ri.x)\n        t, s = symbols('t s')\t\t\n        t1 = t\t\t\n        if self.par == t:\t\t\n            t1 = s\n        return Gerade(p, n, t1)\t\t\n\n    senkrechte = normale\n\n\t\n    def parallele(self, *args, **kwargs):\n        \"\"\"Parallele zu einer Geraden\"\"\"\t\n\t\t\n        if self.dim != 2:\n            print('agla: nur für Geraden in R^2 definiert')\t\t\n            return\n\t\t\t\n        if kwargs.get('h'):\n            print(\"\\nParallele Gerade durch einen gegebenen Punkt oder\")\n            print(\"in einem gegebenem Abstand   (in der Ebene R^2)\\n\")\t\t\n            print(\"Aufruf   gerade . parallele( punkt | abstand )\\n\")\t\t                     \n            print(\"             gerade     Gerade\")\n            print(\"             punkt      Punkt\")\n            print(\"             abstand    Zahl; das Vorzeichen \" + \\\n\t\t\t       \"bestimmt die Lage\\n\")\n            return\t\n\t\t\n        try:\t\t\n            if len(args) != 1:\n                raise AglaError(\"ein Argument angeben\")\n            args = sympify(args[0])\n            if not ((isinstance(args, Vektor) and args.dim == 2) or \\\n\t\t\t     is_zahl(args)):\n                raise AglaError(\"einen Punkt in der Ebene oder eine Zahl \" + \\\n\t\t\t\t        \"angeben\")\n        except AglaError as e:\n            print('agla:', str(e))\n            return\t\t\t\n        if isinstance(args, Vektor):\n            return Gerade(args, self.richt, self.par)\n        stuetz = self.stuetz + self.norm.einh_vekt * args\n        return Gerade(stuetz, self.richt, self.par)\n\t\t   \t\n\t\t\t\n    @property\t\t\n    def hilfe(self):  \n        \"\"\"Bezeichner der Eigenschaften und Methoden\"\"\"\n        if self.dim == 3:\t\t\n            gerade_hilfe(3)\n            return\t\t\t\n        gerade_hilfe(4)\t\n\t\t\n    h = hilfe\t\t\t\t\n\t\n  \n# Benutzerhilfe für Gerade\n# ------------------------\n\ndef gerade_hilfe(h):\n\n    if h == 1:\n        print(\"h=2 - Erzeugung\")\n        print(\"h=3 - Eigenschaften und Methoden im Raum R^3\")\n        print(\"h=4 - Eigenschaften und Methoden in der Ebene R^2\")\n        return\n\t\t   \n    if h == 2:\n        print(\"\\nGerade - Objekt\\n\")\n        print(\"Erzeugung im Raum R^3 und in der Ebene R^2:\\n\")\t\t\n        print(\"             Gerade( stütz, richt /[, par ] )\\n\")\n        print(\"                 stütz    Stützvektor\")\n        print(\"                 richt    Richtungsvektor\")\n        print(\"                 par      Geradenparameter;\") \n        print(\"                          t falls nicht angegeben\\n\")\n        print(\"     oder    Gerade( schar /[, par ] )\\n\") \n        print(\"                 schar   Punkteschar, die eine Gerade bildet\") \n        print(\"                 par     muss bei mehr als einem Parameter in\")\n        print(\"                         schar angegeben werden\\n\")                  \n        print(\"Erzeugung nur in der Ebene R^2:\\n\")                           \n        print(\"             Gerade( m, n )\\n\")\n        print(\"                 m,n     Koeffizienten der Gleichung  y=mx+n\\n\")\n        print(\"     oder    Gerade( a, b, c )\\n\")\n        print(\"                 a,b,c   Koeffizienten der Gleichung  ax+by+c=0\\n\")                   \n        print(\"Zuweisung     g = Gerade(...)   (g - freier Bezeichner)\\n\")\n        print(\"Beispiele\")\n        print(\"A = v(2, -1, 4); B = v(0, 3, -2)\")\n        print(\"Gerade(A, v(A, B)) - Gerade durch 2 Punkte\")\n        print(\"Gerade(2, -3)) - Gerade in R^2 mittels m und n\")\n        print(\"Gerade(v(a+1, 3, 2*a+3)) - Gerade über eine Punkteschar\\n\") \t\t\n        print(\"Vordefinierte Geraden\")\n        print(\"x_achse   ( = xAchse)    x-Achse im Raum R^3\")\n        print(\"y_achse   ( = yAchse)    y-Achse im Raum R^3\")\n        print(\"z_achse   ( = zAchse)    z-Achse im Raum R^3\")\n        print(\"x_achse2  ( = xAchse2)   x-Achse in der Ebene R^2\")\n        print(\"y_achse2  ( = yAchse2)   y-Achse in der Ebene R^2\\n\")\t\t\n        return\n\n    if h == 3:\n        print(\"\\nEigenschaften und Methoden (M) für Gerade im Raum R^3\\n\")\n        print(\"g.hilfe            Bezeichner der Eigenschaften und Methoden\")\n        print(\"g.abstand(...)  M  Abstand zu anderen Objekten\")\n        print(\"g.auf_pkt          = stütz (Aufpunkt)\") \n        print(\"g.bild(...)     M  Bild bei einer Abbildung\")\n        print(\"g.dim              Dimension\")\n        print(\"g.gleich           = g.prg\")\n        print(\"g.gleich_(...)  M  = g.prg_(...)\")\n        print(\"g.is_schar         Test auf Schar\")\n        print(\"g.par              Parameter der Gleichung\")\n        print(\"g.pkt(...)      M  Geradenpunkt\")      \n        print(\"g.prg              Gleichung (Parmeterform)\")\n        print(\"g.prg_(...)     M  ebenso, zugehörige Methode\")\n        print(\"g.proj(...)     M  Projektion auf eine Ebene\")\n        print(\"g.punkte           2 Geradenpunkte\")\n        print(\"g.punkte_(...)  M  ebenso, zugehörige Methode\")\n        print(\"g.richt            Richtungsvektor\")\n        print(\"g.sch_el(...)   M  Element einer Schar\")\n        print(\"g.sch_par          Scharparameter\")\n        print(\"g.schnitt(...)  M  Schnitt mit anderen Objekten\")\n        print(\"g.spur_xy          Spur in der xy-Ebene\")\n        print(\"g.spur_xz          Spur in der xz-Ebene\")\n        print(\"g.spur_yz          Spur in der yz-Ebene\")\n        print(\"g.stütz            Stützvektor\")\n        print(\"g.winkel(...)   M  Winkel mit anderen Objekten\\n\")\n        print(\"Synonyme Bezeichner\\n\")\n        print(\"hilfe    :  h\")\n        print(\"auf_pkt  :  aufPkt\") \n        print(\"gleich_  :  Gleich\")\n        print(\"is_schar :  isSchar\")\n        print(\"prg_     :  Prg\")\n        print(\"punkte_  :  Punkte\")\n        print(\"sch_el   :  schEl\")\n        print(\"sch_par  :  schPar\")\n        print(\"spur_xy  :  spurXY\")\n        print(\"spur_xz  :  spurXZ\")\n        print(\"spur_yz  :  spurYZ\\n\")\n        return\t\n  \n    if h == 4:\n        print(\"\\nEigenschaften und Methoden (M) für Gerade in der Ebene R^2\\n\")\n        print(\"g.hilfe              Bezeichner der Eigenschaften und Methoden\")\n        print(\"g.aagl               Achsenabschnittsgleichung\")\n        print(\"g.abstand(...)    M  Abstand zu anderen Objekten\")\n        print(\"g.anstieg            Anstieg\")\n        print(\"g.auf_pkt          = stütz (Aufpunkt)\") \n        print(\"g.bild(...)       M  Bild bei einer Abbildung\")\n        print(\"g.dim                Dimension\")\n        print(\"g.gleich             = g.prg\")\n        print(\"g.gleich_(...)    M  = g.prg_(...)\")\n        print(\"g.is_schar           Test auf Schar\")\n        print(\"g.fkt                Funktionsgleichung  y=mx+n\")\n        print(\"g.fkt_(...)       M  ebenso, zugehörige Methode\")\n        print(\"g.hnf                Hessesche Normalenform\")\n        print(\"g.koord              Koordinatengleichung  ax+by+c=0\")\n        print(\"g.koord_(...)     M  ebenso, zugehörige Methode\") \n        print(\"g.m                  = anstieg\")\n        print(\"g.n                  = y_abschn\")\n        print(\"g.nf                 Normalenform der Gleichung\")\n        print(\"g.nf_(...)        M  ebenso, zugehörige Methode\")\n        print(\"g.norm               Normalenvektor\")\t\t\n        print(\"g.normale(...)    M  Normale in einem Geradenpunkt\")\t\t\n        print(\"g.par                Parameter der Gleichung\")\n        print(\"g.parallele(...)  M  Parallele Gerade\")\n        print(\"g.pkt(...)        M  Geradenpunkt\")      \n        print(\"g.prg                Parametergleichung\")\n        print(\"g.prg_(...)       M  ebenso, zugehörige Methode\")\n        print(\"g.punkte             2 Geradenpunkte\")\n        print(\"g.punkte_(...)    M  ebenso, zugehörige Methode\")\n        print(\"g.richt              Richtungsvektor\")\n        print(\"g.sch_el(...)     M  Element einer Schar\")\n        print(\"g.sch_par            Scharparameter\")\n        print(\"g.schnitt(...)    M  Schnitt mit anderen Objekten\")\n        print(\"g.senkrechte(...) M  = normale(...)\")\n        print(\"g.stütz              Stützvektor\")\n        print(\"g.winkel(...)     M  Winkel mit anderen Objekten\")\n        print(\"g.y_abschn           Abschnitt auf der y-Achse\\n\")\n        print(\"Synonyme Bezeichner\\n\")\n        print(\"hilfe    :  h\")\n        print(\"auf_pkt  :  aufPkt\") \n        print(\"gleich_  :  Gleich\")\n        print(\"is_schar :  isSchar\")\n        print(\"fkt_     :  Fkt\")\n        print(\"koord_   :  Koord\")\n        print(\"nf_      :  Nf\")\n        print(\"prg_     :  Prg\")\n        print(\"punkte_  :  Punkte\")\n        print(\"sch_el   :  schEl\")\n        print(\"sch_par  :  schPar\")\t\t\n        print(\"y_abschn :  yAbschn\\n\")\n        return\t\n  \n   \n  \n# Vordefinierte Geraden\n \nVektor = importlib.import_module('agla.lib.objekte.vektor').Vektor\t\nt = Symbol(\"t\")\nx_achse = xAchse = Gerade(Vektor(0, 0, 0), Vektor(1, 0, 0), t)\ny_achse = yAchse = Gerade(Vektor(0, 0, 0), Vektor(0, 1, 0), t)\nz_achse = zAchse = Gerade(Vektor(0, 0, 0), Vektor(0, 0, 1), t)\nx_achse2 = xAchse2 = Gerade(Vektor(0, 0), Vektor(1, 0), t)\ny_achse2 = yAchse2 = Gerade(Vektor(0, 0), Vektor(0, 1), t)\n  \n  \n\n  ", "meta": {"hexsha": "a8774dd14b18ce4038715e398c6b17aac269b916", "size": 58912, "ext": "py", "lang": "Python", "max_stars_repo_path": "agla/lib/objekte/gerade.py", "max_stars_repo_name": "HBOMAT/AglaUndZufall", "max_stars_repo_head_hexsha": "3976fecf024a5e4e771d37a6b8056ca4f7eb0da1", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "agla/lib/objekte/gerade.py", "max_issues_repo_name": "HBOMAT/AglaUndZufall", "max_issues_repo_head_hexsha": "3976fecf024a5e4e771d37a6b8056ca4f7eb0da1", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "agla/lib/objekte/gerade.py", "max_forks_repo_name": "HBOMAT/AglaUndZufall", "max_forks_repo_head_hexsha": "3976fecf024a5e4e771d37a6b8056ca4f7eb0da1", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.0922362309, "max_line_length": 102, "alphanum_fraction": 0.4549327811, "include": true, "reason": "import numpy,from numpy,from sympy", "num_tokens": 15425, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.11436852920044106, "lm_q1q2_score": 0.05673752162200349}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     formats: ipynb,py:light\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.5'\n#       jupytext_version: 1.7.1\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# # Video Actor Synchroncy and Causality (VASC)\n# ## RAEng: Measuring Responsive Caregiving Project\n# ### Caspar Addyman, 2020\n# ### https://github.com/infantlab/VASC\n#\n# # Step 2: Reorganise the OpenPose JSON wire frame data\n#\n# This script uses output from [OpenPose](https://github.com/CMU-Perceptual-Computing-Lab/openpose) human figure recognition neural network to create labeled wireframes for each figure in each frame of a video. \n#\n#\n# The `write_json flag` saves the people pose data using a custom JSON writer. Each JSON file has a set of coordinates and confidence scores for each person identified in the frame. For a given person there is:\n#\n# > An array pose_keypoints_2d containing the body part locations and detection confidence formatted as x1,y1,c1,x2,y2,c2,.... The coordinates x and y can be normalized to the range [0,1], [-1,1], [0, source size], [0, output size], etc., depending on the flag keypoint_scale (see flag for more information), while c is the confidence score in the range [0,1].\n#\n# <img src=\"keypoints_pose_25.png\" alt=\"BODY-25 mapping\" width=\"240\"/>\n\n# ## 2.1 - import modules and initialise variables\n\n# +\nimport os                #operating system functions\nimport math              #simple math\nimport glob              #file listing\nimport json              #importing and exporting json files \nimport cv2               #computervision toolkit\nimport numpy as np       #tools for numerical data\nimport pandas as pd      \nimport logging\nimport ipywidgets as widgets  #let's us add buttons and sliders to this page.\nfrom ipycanvas import Canvas\n\n\nimport matplotlib.pyplot as plt\n# %matplotlib inline\n\nimport vasc #a module of our own functions (found in vasc.py in this folder)\n\n#turn on debugging\nlogger = logging.getLogger()\nlogger.setLevel(logging.INFO)\n# %pdb on   \n# -\n\n# #### 2.1.1 - anonymise the videos?\n#\n# Setting the `anon` flag to \n#\n# * `True` - we will not display just the wireframes on black backround without the underlying images from the video. \n# * `False` - we will *attempt to* draw video images - If videos are not available we fall back to anonymous mode \n\nanon = False\n\n# ## 2.2 - Where are the data?\n#\n# This routine only needs to know where to find the processed data  and what are the base names. The summary information is listed in the `videos.json` file we created. The raw numerical data is in `allframedata.npz`.\n\n# +\n# where's the project folder? (without trailing slash)\nprojectpath = \"C:\\\\Users\\\\cas\\\\OneDrive - Goldsmiths College\\\\Projects\\\\Measuring Responsive Caregiving\\\\VASCTutorial\"\n#where are the videos\nvideos_in = \"C:\\\\Users\\\\cas\\\\OneDrive - Goldsmiths College\\\\Projects\\\\Measuring Responsive Caregiving\\\\VASCTutorial\\\\demovideos\"\n\n# locations of videos and output\nvideos_in = projectpath \nvideos_out   = projectpath + \"\\\\out\"\nvideos_out_openpose   = videos_out + \"\\\\openpose\"\nvideos_out_timeseries = videos_out + \"\\\\timeseries\"\nvideos_out_analyses   = videos_out + \"\\\\analyses\"\n\nprint(videos_out_openpose)\nprint(videos_out_timeseries)\nprint(videos_out_analyses)\n# -\n\n#retrieve the list of base names of processed videos.\ntry:\n    with open(videos_out + '\\\\videos.json') as json_file:\n        videos = json.load(json_file)\n        print(\"Existing videos.json found..\")\nexcept:\n    videos = {}\n    print(\"videos.json not found in \", videos_out)\n\n#optional - check the json\nfor vid in videos:  \n    print(vid)\n    for cam in videos[vid]:\n        print(videos[vid][cam])\n\n# ### Step 2.2.1 Load or reload the raw/cleaned data.\n#\n# At this step we can either load the unprocessed data from Step 1 - `allframedata.npz` or we can load a cleaned or partially cleaned set of data that has already by processed in an earlier session - `cleandata.npz`.\n\n# EITHER \n# can reload the original values without recomputing\nreloaded = np.load(videos_out_timeseries + '\\\\allframedata.npz')\n# OR\n# load clean or partially cleaned data from a previous session\n#reloaded = np.load(videos_out_timeseries + '\\\\cleandata.npz')\nkeypoints_original = reloaded[\"keypoints_array\"] #the unprocessed data\n\n\nkeypoints_array = keypoints_original  #an array where we clean the data.\n\n#check the shape\nkeypoints_array.shape\n\n# ## Step 2.3 Clean the data\n#\n# We now have an numpy array called `keypoints_array` containing all the openpose numbers for all videos. Now we need to do some cleaning of the data. We provide set of tools to do this. There are several tasks we need to do.\n#\n# 1. Pick camera with best view of both participants - swap this to camera 1 (if multiple cameras).\n# 2. You might delete sets for whom all data is too poor quality. But they can also be excluded in **Step 3** by a flag in the data spreadsheet. \n# 3. Tag the adult & infant in first frame of interest. So both individuals should be in first frame.\n# 4. Try to automatically tag then in subsequent frames.\n# 5. Manually fix anything the automatic process gets wrong.\n# 6. Exclude other detected people (3rd parties & false positives)\n#\n# We do all of this with the control panel below. \n#\n\n# ### Step 2.3.1: Which is best camera angle?\n#\n# If we have just one camera then use that. If there are multiple angles, pick the best one and swap it to be \"camera1\". \n#\n\n# ### Step 2.3.2: Where does the interesting data start and end?\n#\n# For many videos, the period of interest might start (and end) some time into the video. For now we are using the whole video .\n# TODO  - We wiil give the user the opportunity to set these.\n#\n\n#let's loop through the processed list and set and startframe and endframe for each video\n# for the moment we'll just use the full video.\n# TODO - we will let the use specify this per video \nfor vid in videos:\n    for cam in videos[vid]:\n        videos[vid][cam][\"start\"] = 0\n        videos[vid][cam][\"end\"] = videos[vid][cam][\"frames\"]\n\n# ### Step 2.3.2: Tag the actors of interest at start\n#\n# We want to know which person is the adult and which is the infant in the first frame. We want the child to be Person 0 and Adult to be Person 1. The buttons below provide the choice to swap data series so that this is correct.\n#\n# For example, if child data starts in series 3, we pick 3 in the drop down list next to button `Swap to child (0)` and then press the button. This will swap these two series.\n#\n# This function operates beyond the current frame so it's possible to use it multiple times if data jumps around. However, there is a short cut for part of this process..\n\n# ### Step 2.3.3: Fix by location - Track actors frame by frame\n#\n# At present OpenPose doesn't track individuals from one frame to the next (I believe they are working on this). It just labels each person in each frame. This means that Person 1 in frame 1 might become Person 2 by frame 100. Here we provide some tools that automatically trying to guess who is who. This is tricky so we also ask for human input. \n#\n# Once the child and adult data start in series 0 and 1 respectively, press the `Fix by location` button.\n#\n# If this leaves a few errors we can move slider to affected frame and use the swap series function to manually correct.\n\n# ### Step 2.3.4: Fix by size - identify data by size of wireframes.\n#\n# In many of our cases of interest we have an adult and a young child interacting. Therefore, it is handy to try autolabelling based on a sorting of the size of their wireframes. \n#\n# Pressing the `Fix by size` button, makes person 0 the smallest person in the frame, person 1 the next smallest and so on.\n\n# ### Step 2.3.4: Exclude other people\n#\n# Finally we can delete any people in background or false positives (ghosts) detected by OpenPose. We simply set these to zero.\n\n# ## CONTROL PANEL\n#\n# Run this BIG block of code to provide controls to edit and reorganise the data. \n# If anything goes wrong you can revert to the original data. \n#\n# This needs `ipywidgets` and `ipycanvas` to be installed. (See [Step 0](Step0.GettingStarted.ipynb))\n\n# +\n###############################################################\n# All the code in this block draws our data editing control panel\n###############################################################\n\n###############################################################\n## a canvas object to show current frame of the video.\ncanvas = Canvas(width=800, height=600)\n\n###############################################################\n## dropbown lists to select the video and the camera (if multiple angles)\n## next to the video dropdown we have Delete button to remove that vid\n## next to the camera dropdown we have a swap button to choose a primary camera.\nvidlist = [] #used to fill dropdown options\ncamlist = [] #used to fill dropdown options\nfor vid in videos:  \n    vidlist.append(vid)\n    \nfor cam in videos[vid]:  \n    camlist.append(cam)\n    \npickvid = widgets.Dropdown(\n    options= vidlist,\n    value= vidlist[0],\n    description='Select subject:'\n)\nbutton_exclude =  widgets.Button(description='DELETE THIS ONE!')\n\npickcam = widgets.Dropdown(\n    options= camlist,\n    value= camlist[0],\n    description='Select camera:'\n)\nbutton_swapcam = widgets.Button(description=\"Swap this to camera1\")\ncambox = widgets.HBox([pickcam, button_swapcam])\n\n###############################################################\n## Who is who? \n## In processed video we want child in index 0 and adult in index 1.\n## so need ability to swap series and delete unwanted data.\n## pressing button_swapchild swaps selected set of data to be index 0 - default for child.\n\nbutton_swapchild = widgets.Button(description=\"Swap to child (0)\") \nchild = widgets.Dropdown(\n    options = list(range(10)),\n    value= 0,\n    description='Set: '\n)\nbabybox = widgets.HBox([button_swapchild, child])\n\nadult = widgets.Dropdown(\n    options = list(range(10)),\n    value= 1,\n    description='Set: '\n)\nbutton_swapadult = widgets.Button(description=\"Swap to adult (1)\")\nadultbox = widgets.HBox([button_swapadult,adult])\n\nbutton_remove = widgets.Button(description=\"Remove these data\")\nremove = widgets.Dropdown(\n    options = list(range(10)),\n    value= 2,\n    description='Set: '\n)\nremovebox = widgets.HBox([button_remove,remove])\n\n\n###############################################################\n## What frame is displayed in the canvas?\n## all swap and delete operation work on data AFTER this frame.\n## include a few buttons to adjust the frame forward or backwards slightly\nslider = widgets.IntSlider(\n    value=0,\n    min=0,\n    max=161,\n    step=1,\n    description='Frame:',\n    continuous_update=False,\n    orientation='horizontal',\n    readout=True,\n    readout_format='d',\n    layout=widgets.Layout(width='800px')\n)\n\n#buttons to adjust the slider in small increments \nminus1pct = widgets.Button(description=\"-1%\")\nminus10 = widgets.Button(description=\"-10\")\nminus1 = widgets.Button(description=\"-1\")\nplus1 = widgets.Button(description=\"+1\")\nplus10 = widgets.Button(description=\"+10\")\nplus1pct = widgets.Button(description=\"+1%\")\n\ndef minus1pct_clicked(output):\n    slider.value = max(0,slider.value - 0.01 * slider.max)\ndef minus10_clicked(output):\n    slider.value = max(0,slider.value - 10)\ndef minus1_clicked(output):\n    slider.value = max(0,slider.value - 1)\ndef plus1_clicked(output):\n    slider.value = min(slider.max,slider.value + 1)\ndef plus10_clicked(output):\n    slider.value = min(slider.max,slider.value + 10)\ndef plus1pct_clicked(output):\n    slider.value = min(slider.max,slider.value + 0.01 * slider.max)\n                       \nminus1pct.on_click(minus1pct_clicked)\nminus10.on_click(minus10_clicked)\nminus1.on_click(minus1_clicked)\nplus1.on_click(plus1_clicked)\nplus10.on_click(plus10_clicked)\nplus1pct.on_click(plus1pct_clicked)\n\nadjustbox  = widgets.HBox([minus1pct,minus10,minus1,plus1,plus10,plus1pct])\n\n\n###############################################################\n## Action buttons\n## To redraw everything it's current state, to attempt autofixing or to undo some or all our changes\n\nbutton_update = widgets.Button(description=\"Redraw\")\nbutton_fixlocations = widgets.Button(description=\"Fix by location\",tooltip=\"match each person to nearest person in next frame\")\nbutton_fixsizes = widgets.Button(description=\"Fix by size\",tooltip=\"label people sequentially by size of their wireframe\")\nbutton_reset_one = widgets.Button(description=\"Reset this video\")\nbutton_reset_all = widgets.Button(description=\"Reset all\")\nbuttonbox = widgets.HBox([button_update,button_fixlocations,button_fixsizes,button_exclude,button_reset_one,button_reset_all])\noutput = widgets.Output()\n\n\n###############################################################\n## Widget 'Event' codes\n## watches each widget waiting for something to change and then executes these bits of code. \n\ndef pickvid_change(change):\n    if change['name'] == 'value' and (change['new'] != change['old']):\n        updateAll(True)\n        \ndef pickcam_change(change):\n    if change['name'] == 'value' and (change['new'] != change['old']):\n        updateAll(True)\n\ndef slider_change(slider):\n    updateAll(False)\n\ndef on_button_clicked(output):\n    logging.info('button_update_all clicked')\n    updateAll(True)\n\ndef on_reset_all(output):\n    global keypoints_array\n    logging.info('button_reset_all clicked')\n    keypoints_array = np.copy(keypoints_original)\n    updateAll(True)\n\ndef on_fixlocations(output):\n    global keypoints_array\n    logging.info('on_fixlocations')\n    v = videos[pickvid.value][pickcam.value][\"v\"]\n    c = videos[pickvid.value][pickcam.value][\"c\"]\n    end  = videos[pickvid.value][pickcam.value][\"end\"]\n    window = 10\n    vasc.fixpeopleSeries(keypoints_array,v,c,[0,1],slider.value, end, window)\n    updateAll(True)\n    \ndef on_fixsizes(output):\n    global keypoints_array\n    logging.info('on_fixsizes')\n    v = videos[pickvid.value][pickcam.value][\"v\"]\n    c = videos[pickvid.value][pickcam.value][\"c\"]\n    N = videos[vid][cam][\"maxpeople\"]\n    end  = videos[pickvid.value][pickcam.value][\"end\"]\n    vasc.sortpeoplebySize(keypoints_array,v,c,N,slider.value, end)\n    updateAll(True)\n\ndef on_deleteparticipant(output):\n    global keypoints_array\n    global videos\n    logging.info('on_deleteparticipant')\n    for cam in videos[pickvid.value]: #loop through delete all cameras for this video.\n        v = videos[pickvid.value][cam][\"v\"]\n        c = videos[pickvid.value][cam][\"c\"]\n        end  = videos[pickvid.value][cam][\"end\"]\n        vasc.deleteSeries(keypoints_array,v,c,remove.value,0, end)\n    #now remove this from videos object\n    if pickvid.value in videos:\n        logging.info(pickvid.value)\n        del videos[pickvid.value]\n    #repopulate the dropdown\n    for vid in videos:  \n        vidlist.append(vid)\n    pickvid.options = vidlist\n    updateAll(True)\n    \ndef on_deleteseries(output):\n    global keypoints_array\n    global videos\n    logging.info('on_fixseries')\n    v = videos[pickvid.value][pickcam.value][\"v\"]\n    c = videos[pickvid.value][pickcam.value][\"c\"]\n    end  = videos[pickvid.value][pickcam.value][\"end\"]\n    vasc.deleteSeries(keypoints_array,v,c,remove.value,slider.value, end)\n    updateAll(True)\n\ndef on_swapcam(output):\n    global keypoints_array\n    global videos\n    logging.info('on_swapcam')\n    print(videos[pickvid.value][pickcam.value])\n    videos, keypoints_array = vasc.swapCameras(videos, keypoints_array,pickvid.value,pickcam.value,\"camera1\")\n    updateAll(True)\n    \ndef on_swapchild(output):\n    global keypoints_array\n    global videos\n    logging.info('on_swapchild')\n    v = videos[pickvid.value][pickcam.value][\"v\"]\n    c = videos[pickvid.value][pickcam.value][\"c\"]\n    end  = videos[pickvid.value][pickcam.value][\"end\"]\n    vasc.swapSeries(keypoints_array,v,c,0,child.value,slider.value,end)\n    updateAll(True)\n\ndef on_swapadult(output):\n    global keypoints_array\n    global videos\n    logging.info('on_swapadult')\n    v = videos[pickvid.value][pickcam.value][\"v\"]\n    c = videos[pickvid.value][pickcam.value][\"c\"]\n    end  = int(videos[pickvid.value][pickcam.value][\"end\"])\n    vasc.swapSeries(keypoints_array,v,c,1,adult.value,slider.value,end)\n    updateAll(True)\n\n\nslider.observe(slider_change, 'value')\npickvid.observe(pickvid_change, 'value') \npickcam.observe(pickcam_change, 'value') \nbutton_exclude.on_click(on_deleteparticipant) \nbutton_swapcam.on_click(on_swapcam)\nbutton_swapchild.on_click(on_swapchild)\nbutton_swapadult.on_click(on_swapadult)\nbutton_fixsizes.on_click(on_fixsizes)\nbutton_fixlocations.on_click(on_fixlocations)\nbutton_remove.on_click(on_deleteseries)\nbutton_update.on_click(on_button_clicked)\nbutton_reset_all.on_click(on_reset_all)\n\n###############################################################\n## ## functions to draw complicated stuff..\ndef drawOneFrame(vid, cam, frameNum):\n    # which subarray of data do we need?\n    v = videos[vid][cam][\"v\"]\n    c = videos[vid][cam][\"c\"]\n    if anon == True:\n        #draw a black image\n        frame = np.zeros((videos[vid][cam][\"height\"], videos[vid][cam][\"width\"], 3), dtype = \"uint8\")\n    else:\n        vidpath = videos[pickvid.value][pickcam.value][\"fullpath\"]\n        frame = vasc.getframeimage(vidpath,frameNum) \n    vasc.drawPoints(frame,keypoints_array[v,c,frameNum,:,:],videos[vid][cam][\"maxpeople\"])\n    vasc.drawLines(frame,keypoints_array[v,c,frameNum,:,:],videos[vid][cam][\"maxpeople\"])\n    vasc.drawBodyCG(frame,keypoints_array[v,c,frameNum,:,:],videos[vid][cam][\"maxpeople\"])\n    #send the image to the canvas\n    img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n    hiddencanvas = Canvas(width=img.shape[1], height=img.shape[0])\n    hiddencanvas.put_image_data(img, 0, 0)\n    canvas.draw_image(hiddencanvas,0,0,canvas.width,canvas.height)\n    canvas.restore()\n    \ndef drawMovementGraph(vid, cam, points, frame = 0, average = True):\n    v = videos[vid][cam][\"v\"]\n    c = videos[vid][cam][\"c\"]\n    N = videos[vid][cam][\"frames\"]\n    t = np.zeros([N,1])\n    t[:,0]= list(range(N))\n\n    #variable to track the centre of gravity for each person\n    ceegees = np.zeros([N,videos[vid][cam][\"maxpeople\"]])\n\n    for frameNum in range(N):\n        for p in range(videos[vid][cam][\"maxpeople\"]):\n            personkeypoints = keypoints_array[v,c,frameNum,p,:]\n            avx = vasc.averagePoint(personkeypoints,vasc.xs)\n            if (avx > 0):\n                ceegees[frameNum,p] = avx\n            else:\n                ceegees[frameNum,p] = None\n\n    plt.figure(figsize=(12, 4))\n    plt.plot(t,ceegees)\n    plt.axvline(x=frame,c='tab:cyan')\n    plt.title('Horizontal movement of people (average) over time.)')\n    plt.legend([0, 1, 2, 3])\n    plt.show()\n\n###############################################################\n## Handy update routine to run each time something has changed\ndef updateAll(forceUpdate = False):\n    output.clear_output(wait = True)\n    if forceUpdate:\n        slider.value = 0\n        slider.max = videos[pickvid.value][pickcam.value][\"end\"]\n    with output:\n        display(canvas,pickvid,cambox, babybox,adultbox,removebox, buttonbox, slider, adjustbox)  \n        drawOneFrame(pickvid.value,pickcam.value,slider.value)\n        drawMovementGraph(pickvid.value,pickcam.value,vasc.xs,slider.value,True)\n\n#draw everything for first time\nupdateAll(True)\noutput\n# -\n\n# ### Step 2.4: TODO - Correct for camera motion?\n#\n# Some video sets the camera is not fixed. Any camera movements will cause perfectly correlated movements in the pair of signals. We need to decide what (if anything) to do about this. (Not yet implemented.)\n#\n#\n\n# ### Step 2.5: TODO - Interpolate missing data\n#\n# There are still likely to be gaps. We need to decide what to do about those.  At the moment interpolation is done by scipy in the Step 3 code.\n#\n# #### Step 2.5.1. TODO - autofix to cope with missing data\n#\n# Missing data currently confuses autofix and on it's own interpolation won't help here. Because you can't interpolate until you know who is who. Our current approach is to let autofix by location use a moving average of several previous frames. \n\n# ### Step 2.6: TODO - Save your game\n#\n# Ought to be able to save the array when you half way through cleaning it. So you don't lose progress can come back another time. \n# You can do this manually at the moment by running step 2.7 to save current progress and then restarting by reloading `cleandata.npz` in step 2.2.1 \n\nkeypoints_array.shape\n\n# ## Step 2.7: Save the numpy data!\n#\n# ### *Warning, with BIG datasets, these steps can take multiple minutes each...*\n#\n# Saving the data at this stage so we don't have to repeat these steps again if we reorganise or reanalyse the data.\n#\n# We create a compressed NumPy array `cleandata.npz` containing the person location data for all the videos. \n#\n# We also update the `videos.json` file with more info about the videos. in a new file called `clean.json`. \n#\n\n# +\n#update the json file in the video out directory\nwith open(videos_out + '\\\\clean.json', 'w') as outfile:\n    json.dump(videos, outfile)\n\n# in the time series folder we save the data file. \n#in a compressed format as it has a lot of empty values\nnp.savez_compressed(videos_out_timeseries + '\\\\cleandata.npz', keypoints_array=keypoints_array)\n# -\n\n# ## Step 2.8: Save a pandas dataframe version too.\n#\n# Most of our analysis will be done with SciPy which uses pandas dataframes as its main data format. So let's build a multiindex dataframe containing just the data we need. \n#\n# The rows will have three levels of hierarchy (video x person x BODY25-coordinate). The rows are the individual frames. So a single column will contain the complete time-series of a single dimension of a single point of one person.  So in this example: \n# ```\n# rows 0-411 represent the 412 frames of data.\n#\n# col 0 is x-coordinate of point 0 (nose) of infant in video 'lookit.01'\n# col 1 is y-coordinate of point 0 (nose) of infant in video 'lookit.01'\n# col 2 is openpose confidence score for how well it identified that point.\n# ```\n#\n# <img src=\"multiindexdataframe.png\" alt=\"multiindex\" width=\"871\"/>\n#\n\n#optional\n#can reload the clean values without recomputing steps above\nreloaded = np.load(videos_out_timeseries + '\\\\cleandata.npz')\nkeypoints_array = reloaded[\"keypoints_array\"] #the unprocessed data\nkeypoints_array.shape\n\n#delete all cameras except 0 \nkeypoints_array = np.delete(keypoints_array,np.s_[1:],1)\n#delete all people except 0 & 1\nkeypoints_array = np.delete(keypoints_array,np.s_[2:],3)\n\n\n#truncate the timeseries - many videos are longer than we need\nkeypoints_array = np.delete(keypoints_array,np.s_[10000:],2)\nshp = keypoints_array.shape\nkeypoints_array.shape\n\n\n# Another save point - this array is much smaller so will load / Save quicker.\n\nnp.savez_compressed(videos_out_timeseries + '\\\\trimdata.npz', keypoints_array=keypoints_array)\n\n#Another save point here if it helps.\ntrimmed = np.load(videos_out_timeseries + '\\\\trimdata.npz')\nkeypoints_array = trimmed[\"keypoints_array\"] #the unprocessed data\nkeypoints_array.shape\n\n\n# Now we reorganise the data in a multiindex pandas array and save using `pyarrow`. \n# First create an empty dataframe with right shape\n\n# +\n#first list the three levels of row hierarchy\ntoplevel = videos.keys()\nparticipants = [\"infant\",\"parent\"]\ncoords = list(range(3*vasc.nPoints)) #we have 3 x 25 coordinates to store\n\n#columns are frames\ntimeseries = list(range(shp[2])) #how big is third dimension of the array?\n\ncol_names = ['video','person','coord']\n#row_names = ['frames']\n\ncol_index = pd.MultiIndex.from_product([toplevel,participants,coords], names=col_names)\n\ncleandf = pd.DataFrame(columns=col_index, index = timeseries)\n#cleandf.head()\n# -\n\n# Then populate the dataframe row by row.\n#\n# *This step is particularly SLOW*\n\nfor vid in videos:\n    for p in range(2) :\n        v = videos[vid][\"camera1\"][\"v\"]\n        part = participants[p]\n        for r in range(3*vasc.nPoints):\n            cleandf[(vid, part, r)] = keypoints_array[v,0,:,p,r]\n\n#Sort the columns into alphabetical order (helps with step 3 calculations.)\ncleandf = cleandf.sort_index(axis = 1)\n\n# ### Finally save this to a compressed file.\n#\n# We use the fast `parquet` format with library `pyarrow` in order to preserve our hierarchical index in a compressed format. We save into the timeseries sub-folder. \n#\n\nimport pyarrow.parquet as pq\nimport pyarrow as pa\n\npq.write_table(pa.Table.from_pandas(cleandf), videos_out_timeseries + '\\\\cleandata.parquet')\n\nprint('reading parquet file:')\npqdf = pq.read_table(videos_out_timeseries + '\\\\cleandata.parquet').to_pandas()\nprint(pqdf.head())\n\n\n# #### That's it. \n#\n# Now go onto [Step 3 - Analyse the data](Step3.AnalyseData.scipy)\n", "meta": {"hexsha": "9bf16391a381e2a0154400c1aa66cfa4a05d4e59", "size": 24744, "ext": "py", "lang": "Python", "max_stars_repo_path": "Step2.OrganiseData.py", "max_stars_repo_name": "InfantLab/VASC", "max_stars_repo_head_hexsha": "0d8ea0f49f660ef451aaeacdd81ed4fe14b076d7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2020-07-07T21:52:11.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T16:00:56.000Z", "max_issues_repo_path": "Step2.OrganiseData.py", "max_issues_repo_name": "InfantLab/VASC", "max_issues_repo_head_hexsha": "0d8ea0f49f660ef451aaeacdd81ed4fe14b076d7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-02-15T11:11:20.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-17T11:05:05.000Z", "max_forks_repo_path": "Step2.OrganiseData.py", "max_forks_repo_name": "InfantLab/VASC", "max_forks_repo_head_hexsha": "0d8ea0f49f660ef451aaeacdd81ed4fe14b076d7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-02-27T15:45:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-21T10:16:34.000Z", "avg_line_length": 38.9056603774, "max_line_length": 360, "alphanum_fraction": 0.7032411898, "include": true, "reason": "import numpy", "num_tokens": 6162, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.480478678047907, "lm_q2_score": 0.11757214127540647, "lm_q1q2_score": 0.056490907015269064}}
{"text": "#!/usr/bin/python\n# -*- coding utf-8 -*-\n\n\n\n#                                                 \n#  Start-Programm von zufall           \n#                                                 \n#  Copyright (C) 2019 Holger Böttcher <hbomat@posteo.de>\n#                    \n\n\n_version_ = '0.1.0'\n\n\n# -----------------------------------------------------------------------------\n# Variable zur Steuerung des Testbetriebes\n# -----------------------------------------------------------------------------\n#\n# für den Programmierer; hier im Quelltext ein-/ausschalten\n# _TEST = True:  es werden die vollständigen Python-Fehlermitteilungen angezeigt \n# _TEST = False: es werden (teilweise) zufall-eigene Fehlermitteilungen angezeigt\n\n_TEST = True\n\n\n# -----------------------------------------------------------------------------\n# Zurücksetzen\n# -----------------------------------------------------------------------------\n\n_ip = get_ipython()\n_ip.magic('reset -sf')\n\n\n# -----------------------------------------------------------------------------\n# Importe\n# -----------------------------------------------------------------------------\n\nimport copy\nimport importlib\n\nfrom IPython.core.inputtransformer import InputTransformer\n\nfrom sympy.core.expr import Expr\nfrom sympy.matrices import Matrix as SympyMatrix\n\n# ausgewählte SymPy-Objekte und -funktionen zur unmittelbaren Verfügung des Nutzers\nfrom sympy.abc import *    \nfrom sympy.core.numbers import Integer, Rational, Float, pi, E, I   \nfrom sympy.core.symbol import Symbol, symbols\nfrom sympy.core.function import Lambda\nfrom sympy import (solve, solveset, S, expand, collect, factor, simplify, \n    nsimplify, N, Not, And, Or, factorial, binomial)\n\t\n# Initialisierung der Latex-Ausgabe\t\nfrom sympy.interactive.printing import init_printing\nfrom sympy.printing.latex import LatexPrinter\nLatexPrinter._default_settings[\"mat_delim\"] = \"(\"\ninit_printing(use_latex='mathjax')\t\n\t \n# Import ausgewählter zufall-Elemente\t\nfrom zufall.lib.objekte.umgebung import UMG \nfrom zufall.lib.objekte.ausnahmen import ZufallError\nimport zufall\n\t\t\nfrom agla.lib.objekte.ausnahmen import AglaError\nimport agla\n\n# Alle anderen Objekte und Funktionen werden dynamisch nachgeladen (s.u.)\n\n\n# -----------------------------------------------------------------------------\n# Variable zur Steuerung von internen Vereinfachungen\n# -----------------------------------------------------------------------------\n#\n# Systemvariable, zur interaktiven Benutzung durch den Anwender\n# UMG.SIMPL = True:  in den Programmen vorgesehene Vereinfachungen werden  \n#                    automatisch durchgeführt\n# UMG.SIMPL = False: es werden keine automatischen Vereinfachungen durch-\n#                    geführt \n\nUMG.SIMPL = True\n\n# -----------------------------------------------------------------------------\n# Variable zur Steuerung der Berechnung von hyperbolischen Objekten\n# -----------------------------------------------------------------------------\n#\n# Systemvariable, zur interaktiven Benutzung durch den Anwender\n# UMG.EXAKT = True:  die Berechnungen werden exakt (mit SymPY / SympyEngine) \n#                    durchgeführt\n# UMG.EXAKT = False: die Berechnungen werden mit float-Werten durchgeführt \n\nUMG.EXAKT = False\n\n\t\t\n# -----------------------------------------------------------------------------\n# Dynamisches Importieren\t\n# -----------------------------------------------------------------------------\n\n_attr = 'zufall.lib.objekte.'\n_fkt = 'zufall.lib.funktionen.funktionen'\n_agla = 'agla.lib.objekte.'\n\n\n_to_load = {           \n\n    'v'             : _agla + 'vektor', \n    'Vektor'        : _agla + 'vektor', \n\t'Punkt'         : _agla + 'vektor', \n\t'O'             : _agla + 'vektor', \n    'O2'            : _agla + 'vektor', \n\t'X2'            : _agla + 'vektor',\n    '_ZeilenVektor' : _agla + 'vektor',\t\n\n\t'SympyMatrix'   : _attr + 'markoff_kette',\n\t'Matrix'        : _attr + 'markoff_kette',\n    'NullMat'       : _attr + 'markoff_kette',\n    'NullMat2'      : _attr + 'markoff_kette', \n    'EinhMat'       : _attr + 'markoff_kette',\n    'EinhMat2'      : _attr + 'markoff_kette',\n\t\t \t\t \n    'DatenReihe'                  : _attr + 'datenreihe', \n    'DR'                          : _attr + 'datenreihe', \n    'ZufallsGroesse'              : _attr + 'zufalls_groesse', \n\t'ZG'                          : _attr + 'zufalls_groesse', \n\t'BinomialVerteilung'          : _attr + 'binomial_verteilung', \n\t'BV'                          : _attr + 'binomial_verteilung', \n\t'HyperGeometrischeVerteilung' : _attr + 'hyper_geometrische_verteilung', \n\t'HGV'                         : _attr + 'hyper_geometrische_verteilung',\n\t'GeometrischeVerteilung'      : _attr + 'geometrische_verteilung', \n\t'GV'                          : _attr + 'geometrische_verteilung', \n\t'PoissonVerteilung'           : _attr + 'poisson_verteilung', \n\t'PV'                          : _attr + 'poisson_verteilung',\n\t'GleichVerteilung'            : _attr + 'gleich_verteilung', \n\t'GLV'                         : _attr + 'gleich_verteilung', \n\t'NormalVerteilung'            : _attr + 'normal_verteilung', \n\t'NV'                          : _attr + 'normal_verteilung',\n\t'ExponentialVerteilung'       : _attr + 'exponential_verteilung', \n\t'EV'                          : _attr + 'exponential_verteilung', \n\t'BernoulliKette'              : _attr + 'bernoulli_kette', \n\t'BK'                          : _attr + 'bernoulli_kette',\n\t'ZufallsExperiment'           : _attr + 'zufalls_experiment', \n\t'ZE'                          : _attr + 'zufalls_experiment', \n\t'ZufallsVersuch'              : _attr + 'zufalls_experiment', \n\t'ZV'                          : _attr + 'zufalls_experiment',\n\t'Urne'                        : _attr + 'urne', \n\t'GluecksRad'                  : _attr + 'gluecks_rad', \n\t'Rad'                         : _attr + 'gluecks_rad', \n\t'GR'                          : _attr + 'gluecks_rad', \n\t'Muenze'                      : _attr + 'muenze', \n\t'Wuerfel'                     : _attr + 'wuerfel',\n\t'HaeufigkeitsBaum'            : _attr + 'haeufigkeits_baum', \n\t'HB'                          : _attr + 'haeufigkeits_baum', \n\t'VierFelderTafel'             : _attr + 'vier_felder_tafel', \n\t'VT'                          : _attr + 'vier_felder_tafel',\n    'KonfidenzIntervall'          : _attr + 'konfidenz_intervall', \n\t'KI'                          : _attr + 'konfidenz_intervall', \n\t'EreignisAlgebra'             : _attr + 'ereignis_algebra', \n\t'EA'                          : _attr + 'ereignis_algebra',\n    'AlternativTest'              : _attr + 'alternativ_test', \n\t'AT'                          : _attr + 'alternativ_test', \n\t'SignifikanzTestP'            : _attr + 'signifikanz_test_p', \n\t'STP'                         : _attr + 'signifikanz_test_p',\n\t'SkatBlatt'                   : _attr + 'skat_blatt', \n\t'Skat'                        : _attr + 'skat_blatt', \n\t'Roulette'                    : _attr + 'roulette', \n\t'Craps'                       : _attr + 'craps', \n\t'Toto'                        : _attr + 'toto', \n\t'Lotto'                       : _attr + 'lotto',\n\t'Chuck'                       : _attr + 'chuck',\n\t'ChuckALuck'                  : _attr + 'chuck', \n\t'MarkoffKette'                : _attr + 'markoff_kette', \n\t'MK'                          : _attr + 'markoff_kette',\n        \n    'permutationen'  : _fkt, \n    'perm'           : _fkt, \n\t'kombinationen'  : _fkt, \n    'komb'           : _fkt, \n    'variationen'    : _fkt, \n\t'anzahl'         : _fkt, \n    'anzahl_treffer' : _fkt, \n\t'anzahlTreffer'  : _fkt, \n\t'summe'          : _fkt, \n\t'zuf_zahl'       : _fkt, \n\t'zufZahl'        : _fkt, \n\t'fakultaet'      : _fkt, \n\t'fak'            : _fkt, \n\t'binomial'       : _fkt, \n\t'B'              : _fkt, \n\t'loese'          : _fkt, \n\t'Hilfe'          : _fkt, \n\t'auswahlen'      : _fkt, \n\t'gesetze'        : _fkt, \n\t'stochastisch'   : _fkt, \n\t'einfach'        : _fkt,\t\n\t'is_zahl'        : _fkt, \n\t'isZahl'         : _fkt, \n\t'mit_param'   \t : _fkt,\n\t'mitParam'       : _fkt,\n    'jaNein'         : _fkt, \n    'kurz_form'      : _fkt, \n    'kurzForm'       : _fkt, \n\t'ja_nein'        : _fkt, \n\t'ja'             : _fkt, \n\t'Ja'             : _fkt, \n\t'nein'           : _fkt, \n\t'Nein'           : _fkt, \n\t'mit'            : _fkt, \n\t'Mit'            : _fkt, \n\t'ohne'           : _fkt, \n\t'Ohne'           : _fkt,\n\t\n    'abs'            : _fkt, \n\t'sqrt'           : _fkt, \n\t'exp'            : _fkt, \n\t'ln'             : _fkt, \n\t'lg'             : _fkt, \n\t'log'            : _fkt, \n    'sin'            : _fkt, \n\t'cos'            : _fkt, \n\t'tan'            : _fkt, \n\t'cot'            : _fkt, \n\t'sing'           : _fkt, \n\t'cosg'           : _fkt, \n\t'tang'           : _fkt, \n\t'cotg'           : _fkt, \n    'arcsin'         : _fkt, \n\t'arccos'         : _fkt, \n\t'arctan'         : _fkt, \n\t'arccot'         : _fkt, \n\t'asin'           : _fkt, \n\t'acos'           : _fkt, \n\t'atan'           : _fkt, \n\t'acot'           : _fkt,\n    'arcsing'        : _fkt, \n\t'arccosg'        : _fkt, \n\t'arctang'        : _fkt, \n\t'arccotg'        : _fkt, \n\t'asing'          : _fkt, \n\t'acosg'          : _fkt, \n\t'atang'          : _fkt, \n\t'acotg'          : _fkt, \t\n    'sinh'           : _fkt, \n\t'cosh'           : _fkt, \n\t'tanh'           : _fkt, \n\t'arsinh'         : _fkt, \n\t'arcosh'         : _fkt, \n\t'artanh'         : _fkt, \n\t'asinh'          : _fkt, \n\t'acosh'          : _fkt, \n\t'atanh'          : _fkt,\n    're'             : _fkt, \n\t'im'             : _fkt, \n\t'conjugate'      : _fkt, \n\t'konjugiert'     : _fkt, \n\t'max'            : _fkt, \n\t'min'            : _fkt, \n\t'deg'            : _fkt, \n\t'grad'           : _fkt, \n\t'rad'            : _fkt, \n\t'bog'            : _fkt\t\n\t\t\n\t}\t\t\n\n# -----------------------------------------------------------------------------\n# Geschützte Namen\n# -----------------------------------------------------------------------------\n\nzufall_namen = list(_to_load.keys())\ndel zufall_namen[zufall_namen.index('B')]\n\n_protected_names = zufall_namen + [\n\n        # Python-Namen\n        'and', 'as', 'assert', 'break', 'class', 'continue', \n        'def', 'del', 'elif', 'else', 'except', 'exec', \n        'finally', 'float', 'for', 'from', 'global', 'if', 'import', \n        'in', 'int', 'is', 'lambda', 'not', 'or', 'pass', 'print', \t\t\n\t\t'raise', 'return', 'try', 'while', 'with', 'yield',\t\t\n\n        # SymPy-Namen\t\t  \n        'Rational', 'pi', 'Symbol', 'symbols', 'solve', 'solveset', \n        'nsolve', 'expand', 'simplify', 'nsimplify', 'collect', 'diff',\n        'factor', 're', 'im', 'min', 'max', 'conjugate', 'sympify',\t\n\t\t\n        # griechische Buchstaben\t\n        'alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta', 'eta', \n\t\t 'theta', 'iota', 'kappa', 'lamda', 'mu', 'nu', 'xi', 'omicron', \n\t\t 'pi', 'rho', 'sigma', 'tau', 'upsilon', 'phi', 'chi', 'psi', \n\t\t 'omega'  \n      ]\n\n# -----------------------------------------------------------------------------\n# Funktion zum Laden der Moduln\t\n# -----------------------------------------------------------------------------\n\ndef _load_modules(line):\n\n    for obj in _to_load:\n        if obj in line and _to_load[obj] != False:\n            name = _to_load[obj]\n            modul = importlib.import_module(name)\n            attribut = getattr(modul, obj)\n            _ip.push({obj : attribut})\t\t\n            _to_load[obj] = False\t\n\t\n# -----------------------------------------------------------------------------\n# Custom InputTransformer\n# -----------------------------------------------------------------------------\n#\n#   Für\n#\n# - Dynamisches Laden der Moduln\n#\n# - Ersetzen der deutschen Umlaute und ß\n#\n#  - Operator '^'   für das Potenzieren (zusätzlich zu '**')\n#    Operator '°'   für das Skalarprodukt und die Verknüpfung \n#                   von Abbildungen (zusätzlich zu '*')\n#    Operator '><'  für das Kreuzprodukt (Vektorprodukt)\n#\n# - Schreibwarnung für die zufall-, Python- und SymPy-Namen\n#\n#  (s.a. 'ipython/core/test/test_interactiveshell.py')\n\t\t\nclass ZufallInputTransformer(InputTransformer):\n\t\n    def push(self, line):\n        \"\"\"für InputTransformer erforderlich\"\"\"\n\t\t\n\t\t# Operatoren, Umlaute\n        #\t\t \n        if line.find('^') >= 0:\n            line = line.replace('^', '**')\t\t\t\n        if line.find('°') >= 0:\n            line = line.replace('°', '*')\n        if line.find('><') >= 0:\n            line = line.replace('><', '&')\n\t\t\t\n        if line.find('ä') >= 0:\n            line = line.replace('ä', 'ae')\t\t\t\n        if line.find('ö') >= 0:\n            line = line.replace('ö', 'oe')\t\t\t\n        if line.find('ü') >= 0:\n            line = line.replace('ü', 'ue')\t\t\t\n        if line.find('ß') >= 0:\n            line = line.replace('ß', 'ss')\t\t\t\n\t\t\n        # Dynamisches Laden der Moduln\n        #   \n        _load_modules(line)\n\t\t\n        # Schreibblockade\t\n        #\n\t\t\n        def klammer(line):    # Index der 1. Klammer oder None\n            for i, z in enumerate(line):\n                if z in '([{':\n                    return i\n        def gleich(line):   # Indices aller '='-Zeichen vor der 1. Klammer \n            line1 = line.replace('==', 'xx')\t # '==' ausschließen\t\n            k = klammer(line1)\n            g = []\n            for i, z in enumerate(line1):\n                if i == k:\n                    break\n                if z == '=':\n                    g.append(i)\n            return g \n\t\t\t\n        if '#' in line:\n            k = line.find('#')\n            kl = False\t\t\t   \t\n            for i in range(k): \n                if line[i] in '([{)]}':\n                    kl = not kl\n            if not kl:\t\t# innere Kommentare bleiben erhalten\n               line = line[:k]\t\n        anw_liste = line.split(';')  # Behandlung von Mehrfachzuweisungen\n\t\n        anw_liste_neu = []\t\t\n        for i, anw in enumerate(anw_liste):\n            gl = gleich(anw)\n            no1 = anw.find(\"'\")\t\t\n            no2 = anw.find('\"')   \t\t\n            for i, g in enumerate(gl):\n                if abs(no1) < gl[i] or abs(no2) < gl[i]:\n                    gl = gl[:i]  \n                    break\t\t\t\t\t\t\t\t\n            if len(gl) <= 1:\n                anw_liste_neu.append(anw)\n                continue \n            lhs, rhs = anw[:gl[-1]], anw[gl[-1]:]\n            ind = ''\n            for i in lhs:\n                if i == ' ':\n                    ind += ' '\n                else:\n                    break\t\t\t\t\n            lhs = lhs.split('=') \n            anw_neu = []\n            for i, name in enumerate(lhs):\n                if i == 0:\t\t\t\n                    anw_liste_neu.append(name + rhs)\t\n                else:\t\t\t\t\t\n                    anw_liste_neu.append(ind + name[1:] + rhs)\t\n        anw_liste = anw_liste_neu \t\n        \n        aus_liste = []  \n        for anw in anw_liste:\n            anw = anw.rstrip()\n            g = anw.find('=')\n            if g <= 0:\n                aus_liste += [anw] \n                continue \n            try:\n                if anw[g+1] == '=':\n                    aus_liste += [anw] \n                    continue \t\t\t\t\n            except IndexError:\n                pass\t\t\t\n            klammer = False\t\t\t   \t\n            for i in range(len(anw)):   \n                if i == g:\n                    break\n                if anw[i] in '([{)]}':\n                    klammer = not klammer\n            if klammer:\n                aus_liste += [anw]\n                continue \n            if anw[g-1] in ('<', '>', '!'):    \n                aus_liste += [anw] \n                continue\n            bezeichner = anw[:g].strip() \n            fehler = False   \n            if bezeichner in _protected_names:\n                print(\"zufall: der Wert von \" + bezeichner + \" kann nicht überschrieben werden\")\n                fehler = True\n            if anw[0] == '_':\n                print(\"zufall: ein Bezeichner darf nicht mit einem Unterstrich beginnen\")\n                fehler = True\n            p = anw.find('.')\n            if 0 <= p < g and klammer and not 'UMG.' in anw:\n                print(\"zufall: auf der linken Seite einer Zuweisung darf kein '.' auftreten\")\n                fehler = True\n            if not fehler:        \n                aus_liste += [anw]\n                continue\n            else:\n                return\n        \n        return ';'.join(aus_liste)\n\t\t\t\t\t  \n    def reset(self):\n        \"\"\"für InputTransformer erforderlich\"\"\"\t\n        pass\n\ntransformer = ZufallInputTransformer()\n_ip.input_splitter.python_line_transforms.append(transformer)\n_ip.input_transformer_manager.python_line_transforms.append(transformer)\n\t \n\t\t\n# -----------------------------------------------------------------------------\n# Eigene Fehlermeldungen\n# -----------------------------------------------------------------------------\n\t\n# Extra-Behandlung von SyntaxError (hat kein traceback)\t \n#\n\nimport linecache \nfrom IPython.core.ultratb import SyntaxTB\nfrom IPython.utils import py3compat\nfrom IPython.utils import ulinecache\ndef new_structured_traceback(self, etype, value, elist, tb_offset=None,\n                             context=5):\n    if isinstance(value, SyntaxError) \\\n            and isinstance(value.filename, py3compat.string_types) \\\n            and isinstance(value.lineno, int):\n        linecache.checkcache(value.filename)\n        newtext = ulinecache.getline(value.filename, value.lineno)\n        if newtext:\n            value.text = newtext\n    nr = value.lineno\t\t\n    print('SyntaxError:  ' + value.text[:-1] + (('  /Zeile ' + str(nr) + '/') \\\n\t      if nr > 1 else ''))\n    return\t\t\n\nif not _TEST:\t\n    SyntaxTB.structured_traceback = new_structured_traceback\n\t\n\n# Custom exc_handler (für ausgewählte Ausnahmen)\n#\ndef exc_handler(shell, etype, value, tb, tb_offset=None):\n    stype, sval = str(etype), str(value)\n    if 'ZufallError' in stype or 'AglaError' in stype:\n        print(sval)\n    elif 'NameError' in stype:\n        txt = sval[sval.find(\"'\")+1 : sval.rfind(\"'\")]\t\t\n        print('NameError: ' + txt + ' ist nicht definiert')\t\t\n    elif 'KeyError' in stype:\n        print('KeyError: ' + sval)\n    elif 'IndexError' in stype:\n        print('IndexError: ' + 'der Index ist außerhalb des Bereiches')\n    elif 'AttributeError' in stype:\n        no = []\n        for i, z in enumerate(sval):\n            if z == \"'\":\n                no += [i]\n        if len(no) != 4:\t\t\n            print('AttributeError')\n        else:\n            obj, eig = sval[no[0]+1:no[1]], sval[no[2]+1:no[3]]\t\t\n            print('AttributeError:  ' + 'ein ' + obj + '-Objekt ' + \\\n                 'hat keine Eigenschaft/Methode \\nmit dem Namen ' + eig)\n    elif 'TypeError' in stype:\n        print('TypeError: ' + 'Funktionsaufruf nicht möglich oder anderer Fehler')\n    elif 'MemoryError' in stype:\n        print('MemoryError: ' + 'die Zahlen sind zu groß')\n    elif 'ImportError' in stype:\n        i = sval.find(\"'\")\n        j = sval[i+1:].find(\"'\")\n        txt = sval[i+1:i+j+1]\t\n        print('ImportError: ' + txt +  ' kann nicht importiert werden')\n    elif 'ZeroDivisionError' in stype:\n        print('ZeroDivisionError: ' +\t 'Division durch Null ist nicht erlaubt')\n    elif 'IndentationError' in stype:\n        print('IndentationError: ' +\t 'Syntaxfehler - falsche Einrückung')\n    elif 'RuntimeError' in stype:\n        print('RuntimeError: ' +\t    'Ein Laufzeitfehler ist aufgetreten')\n    elif 'ValueError' in stype:\n        print('ValueError: ' +\t    'Ein ValueError ist aufgetreten')\n    return\t\n\t\nif not _TEST:\t\n    _ip.set_custom_exc((ZufallError, AglaError, NameError, KeyError, IndexError, \\\n      AttributeError, TypeError, MemoryError, ImportError, ZeroDivisionError, \\\n      IndentationError, RuntimeError), exc_handler) \n\t\n\t\n# -----------------------------------------------------------------------------\n# Ausführung der (linksseitigen) Multiplikation  Zahl * Vektor\n# -----------------------------------------------------------------------------\n\n\"\"\"\nDie rechtsseitige Multiplikation eines Vektors mit einer Zahl \n(Vektor * Zahl) funktioniert für alle infrage kommenden SymPy-Klassen,\ndas Ergebnis ist ein Vektor-Objekt\nHinsichtlich der linksseitigen Multiplikation (Zahl * Vektor) verhalten\nsich die Klassen unterschiedlich. Bei einigen gibt die __mul__-Methode\nNotImplemented zurück, sodass automatisch die __rmul__-Methode von Vektor\naufgerufen wird. Für die anderen wird dieses Verhalten mittels Überladen\nder __mul__-Methode des Expr-Objektes bzw. ihrer eigenen __mul__-Methode\n(Symbol) erreicht\n\"\"\"\n\n# -----------------------------------------------------------------------------\n# Überladen der Expr.__mul__- Methode\n# -----------------------------------------------------------------------------\n\n_expr_mul = copy.deepcopy(Expr.__mul__)\ndef _expr_mul_anpassung(self, other):\n    Vektor = importlib.import_module('agla.lib.objekte.vektor').Vektor\n    if isinstance(other, (Vektor, SympyMatrix)):\n        return NotImplemented\n    return _expr_mul(self, other)\nExpr.__mul__ = _expr_mul_anpassung\t\n   \n   \n# -----------------------------------------------------------------------------\n# Überladen der Symbol.__mul__- Methode\t\n# -----------------------------------------------------------------------------\n\n_symbol_mul = copy.deepcopy(Symbol.__mul__)\ndef _symbol_mul_anpassung(self, other):\n    Vektor = importlib.import_module('agla.lib.objekte.vektor').Vektor\n    if isinstance(other, (Vektor, SympyMatrix)):\n        return NotImplemented\n    return _symbol_mul(self, other)\nSymbol.__mul__ = _symbol_mul_anpassung\t   \n\t\n# -----------------------------------------------------------------------------\n# Float.__mul__ - Überladung\n# -----------------------------------------------------------------------------\n\n_Float_mul = copy.deepcopy(Float.__mul__)\n\ndef _Float_mul_anpassung(self, other):\n    if isinstance(other, SympyMatrix):\n        ve = [self*v for v in other.vekt]\n        return Matrix(*ve)\n    return _Float_mul(self, other) \n\t\nFloat.__mul__ = _Float_mul_anpassung\t\n\t\n\n\t\n\t \n\n\n", "meta": {"hexsha": "676f2fcdf6d66986e3effa21e7f8761ab53cd1e3", "size": 21855, "ext": "py", "lang": "Python", "max_stars_repo_path": "zufall/lib/start.py", "max_stars_repo_name": "HBOMAT/AglaUndZufall", "max_stars_repo_head_hexsha": "3976fecf024a5e4e771d37a6b8056ca4f7eb0da1", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "zufall/lib/start.py", "max_issues_repo_name": "HBOMAT/AglaUndZufall", "max_issues_repo_head_hexsha": "3976fecf024a5e4e771d37a6b8056ca4f7eb0da1", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "zufall/lib/start.py", "max_forks_repo_name": "HBOMAT/AglaUndZufall", "max_forks_repo_head_hexsha": "3976fecf024a5e4e771d37a6b8056ca4f7eb0da1", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.3643926789, "max_line_length": 96, "alphanum_fraction": 0.4722946694, "include": true, "reason": "from sympy", "num_tokens": 5957, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4301473631961697, "lm_q2_score": 0.13117322885652913, "lm_q1q2_score": 0.056423818514563726}}
{"text": "# sage.doctest: optional - sage.graphs\nr\"\"\"\nBase class for polyhedra, part 4\n\nDefine methods relying on :mod:`sage.graphs`.\n\"\"\"\n\n# ****************************************************************************\n#       Copyright (C) 2008-2012 Marshall Hampton <hamptonio@gmail.com>\n#       Copyright (C) 2011-2015 Volker Braun <vbraun.name@gmail.com>\n#       Copyright (C) 2012-2018 Frederic Chapoton\n#       Copyright (C) 2013      Andrey Novoseltsev\n#       Copyright (C) 2014-2017 Moritz Firsching\n#       Copyright (C) 2014-2019 Thierry Monteil\n#       Copyright (C) 2015      Nathann Cohen\n#       Copyright (C) 2015-2017 Jeroen Demeyer\n#       Copyright (C) 2015-2017 Vincent Delecroix\n#       Copyright (C) 2015-2018 Dima Pasechnik\n#       Copyright (C) 2015-2020 Jean-Philippe Labbe <labbe at math.huji.ac.il>\n#       Copyright (C) 2015-2021 Matthias Koeppe\n#       Copyright (C) 2016-2019 Daniel Krenn\n#       Copyright (C) 2017      Marcelo Forets\n#       Copyright (C) 2017-2018 Mark Bell\n#       Copyright (C) 2019      Julian Ritter\n#       Copyright (C) 2019-2020 Laith Rastanawi\n#       Copyright (C) 2019-2020 Sophia Elia\n#       Copyright (C) 2019-2021 Jonathan Kliem <jonathan.kliem@fu-berlin.de>\n#\n# This program is free software: you can redistribute it and/or modify\n# it under the terms of the GNU General Public License as published by\n# the Free Software Foundation, either version 2 of the License, or\n# (at your option) any later version.\n#                  https://www.gnu.org/licenses/\n# ****************************************************************************\n\nfrom sage.misc.cachefunc import cached_method\nfrom .base3 import Polyhedron_base3\n\nclass Polyhedron_base4(Polyhedron_base3):\n    \"\"\"\n    Methods relying on :mod:`sage.graphs`.\n\n    See :class:`sage.geometry.polyhedron.base.Polyhedron_base`.\n\n    TESTS::\n\n        sage: from sage.geometry.polyhedron.base4 import Polyhedron_base4\n        sage: P = polytopes.cube()\n        sage: Polyhedron_base4.vertex_facet_graph.f(P)\n        Digraph on 14 vertices\n        sage: Polyhedron_base4.vertex_graph(P)\n        Graph on 8 vertices\n        sage: Polyhedron_base4.face_lattice(P)\n        Finite lattice containing 28 elements\n        sage: Polyhedron_base4.flag_f_vector(P, 0, 2)\n        24\n        sage: Polyhedron_base4.is_self_dual(P)\n        False\n        sage: Q = polytopes.cube(intervals='zero_one')\n        sage: P == Q\n        False\n        sage: Polyhedron_base4.is_combinatorially_isomorphic(P, Q)\n        True\n    \"\"\"\n\n    @cached_method\n    def vertex_facet_graph(self, labels=True):\n        r\"\"\"\n        Return the vertex-facet graph.\n\n        This function constructs a directed bipartite graph.\n        The nodes of the graph correspond to the vertices of the polyhedron\n        and the facets of the polyhedron. There is an directed edge\n        from a vertex to a face if and only if the vertex is incident to the face.\n\n        INPUT:\n\n        - ``labels`` -- boolean (default: ``True``); decide how the nodes\n          of the graph are labelled. Either with the original vertices/facets\n          of the Polyhedron or with integers.\n\n        OUTPUT:\n\n        - a bipartite DiGraph. If ``labels`` is ``True``, then the nodes\n          of the graph will actually be the vertices and facets of ``self``,\n          otherwise they will be integers.\n\n        .. SEEALSO::\n\n            :meth:`combinatorial_automorphism_group`,\n            :meth:`is_combinatorially_isomorphic`.\n\n        EXAMPLES::\n\n            sage: P = polytopes.cube()\n            sage: G = P.vertex_facet_graph(); G\n            Digraph on 14 vertices\n            sage: G.vertices(key = lambda v: str(v))\n            [A vertex at (-1, -1, -1),\n             A vertex at (-1, -1, 1),\n             A vertex at (-1, 1, -1),\n             A vertex at (-1, 1, 1),\n             A vertex at (1, -1, -1),\n             A vertex at (1, -1, 1),\n             A vertex at (1, 1, -1),\n             A vertex at (1, 1, 1),\n             An inequality (-1, 0, 0) x + 1 >= 0,\n             An inequality (0, -1, 0) x + 1 >= 0,\n             An inequality (0, 0, -1) x + 1 >= 0,\n             An inequality (0, 0, 1) x + 1 >= 0,\n             An inequality (0, 1, 0) x + 1 >= 0,\n             An inequality (1, 0, 0) x + 1 >= 0]\n            sage: G.automorphism_group().is_isomorphic(P.hasse_diagram().automorphism_group())\n            True\n            sage: O = polytopes.octahedron(); O\n            A 3-dimensional polyhedron in ZZ^3 defined as the convex hull of 6 vertices\n            sage: O.vertex_facet_graph()\n            Digraph on 14 vertices\n            sage: H = O.vertex_facet_graph()\n            sage: G.is_isomorphic(H)\n            False\n            sage: G2 = copy(G)\n            sage: G2.reverse_edges(G2.edges())\n            sage: G2.is_isomorphic(H)\n            True\n\n        TESTS:\n\n        Check that :trac:`28828` is fixed::\n\n            sage: G._immutable\n            True\n\n        Check that :trac:`29188` is fixed::\n\n            sage: P = polytopes.cube()\n            sage: P.vertex_facet_graph().is_isomorphic(P.vertex_facet_graph(False))\n            True\n        \"\"\"\n        return self.combinatorial_polyhedron().vertex_facet_graph(names=labels)\n\n    def vertex_graph(self, **kwds):\n        \"\"\"\n        Return a graph in which the vertices correspond to vertices\n        of the polyhedron, and edges to edges.\n\n        INPUT:\n\n        - ``names`` -- boolean (default: ``True``); if ``False``,\n          then the nodes of the graph are labeld by the\n          indices of the Vrepresentation\n\n        - ``algorithm`` -- string (optional);\n          specify whether the face generator starts with facets or vertices:\n          * ``'primal'`` -- start with the facets\n          * ``'dual'`` -- start with the vertices\n          * ``None`` -- choose automatically\n\n        ..NOTE::\n\n            The graph of a polyhedron with lines has no vertices,\n            as the polyhedron has no vertices (`0`-faces).\n\n            The method :meth:`Polyhedron_base:vertices` returns\n            the defining points in this case.\n\n        EXAMPLES::\n\n            sage: g3 = polytopes.hypercube(3).vertex_graph(); g3\n            Graph on 8 vertices\n            sage: g3.automorphism_group().cardinality()\n            48\n            sage: s4 = polytopes.simplex(4).vertex_graph(); s4\n            Graph on 5 vertices\n            sage: s4.is_eulerian()\n            True\n\n        The graph of an unbounded polyhedron\n        is the graph of the bounded complex::\n\n            sage: open_triangle = Polyhedron(vertices=[[1,0], [0,1]],\n            ....:                            rays    =[[1,1]])\n            sage: open_triangle.vertex_graph()\n            Graph on 2 vertices\n\n        The graph of a polyhedron with lines has no vertices::\n\n            sage: line = Polyhedron(lines=[[0,1]])\n            sage: line.vertex_graph()\n            Graph on 0 vertices\n\n        TESTS:\n\n        Check for a line segment (:trac:`30545`)::\n\n            sage: polytopes.simplex(1).graph().edges()\n            [(A vertex at (0, 1), A vertex at (1, 0), None)]\n        \"\"\"\n        return self.combinatorial_polyhedron().vertex_graph(**kwds)\n\n    graph = vertex_graph\n\n    def vertex_digraph(self, f, increasing=True):\n        r\"\"\"\n        Return the directed graph of the polyhedron according to a linear form.\n\n        The underlying undirected graph is the graph of vertices and edges.\n\n        INPUT:\n\n        - ``f`` -- a linear form. The linear form can be provided as:\n\n            - a vector space morphism with one-dimensional codomain, (see\n              :meth:`sage.modules.vector_space_morphism.linear_transformation`\n              and\n              :class:`sage.modules.vector_space_morphism.VectorSpaceMorphism`)\n            - a vector ; in this case the linear form is obtained by duality\n              using the dot product: ``f(v) = v.dot_product(f)``.\n\n        - ``increasing`` -- boolean (default ``True``) whether to orient\n          edges in the increasing or decreasing direction.\n\n        By default, an edge is oriented from `v` to `w` if\n        `f(v) \\leq f(w)`.\n\n        If `f(v)=f(w)`, then two opposite edges are created.\n\n        EXAMPLES::\n\n            sage: penta = Polyhedron([[0,0],[1,0],[0,1],[1,2],[3,2]])\n            sage: G = penta.vertex_digraph(vector([1,1])); G\n            Digraph on 5 vertices\n            sage: G.sinks()\n            [A vertex at (3, 2)]\n\n            sage: A = matrix(ZZ, [[1], [-1]])\n            sage: f = linear_transformation(A)\n            sage: G = penta.vertex_digraph(f) ; G\n            Digraph on 5 vertices\n            sage: G.is_directed_acyclic()\n            False\n\n        .. SEEALSO::\n\n            :meth:`vertex_graph`\n        \"\"\"\n        from sage.modules.vector_space_morphism import VectorSpaceMorphism\n        if isinstance(f, VectorSpaceMorphism):\n            if f.codomain().dimension() == 1:\n                orientation_check = lambda v: f(v) >= 0\n            else:\n                raise TypeError('the linear map f must have '\n                                'one-dimensional codomain')\n        else:\n            try:\n                if f.is_vector():\n                    orientation_check = lambda v: v.dot_product(f) >= 0\n                else:\n                    raise TypeError('f must be a linear map or a vector')\n            except AttributeError:\n                raise TypeError('f must be a linear map or a vector')\n        if not increasing:\n            f = -f\n        from sage.graphs.digraph import DiGraph\n        dg = DiGraph()\n        for j in range(self.n_vertices()):\n            vj = self.Vrepresentation(j)\n            for vi in vj.neighbors():\n                if orientation_check(vj.vector() - vi.vector()):\n                    dg.add_edge(vi, vj)\n        return dg\n\n    def face_lattice(self):\n        \"\"\"\n        Return the face-lattice poset.\n\n        OUTPUT:\n\n        A :class:`~sage.combinat.posets.posets.FinitePoset`. Elements\n        are given as\n        :class:`~sage.geometry.polyhedron.face.PolyhedronFace`.\n\n        In the case of a full-dimensional polytope, the faces are\n        pairs (vertices, inequalities) of the spanning vertices and\n        corresponding saturated inequalities. In general, a face is\n        defined by a pair (V-rep. objects, H-rep. objects). The\n        V-representation objects span the face, and the corresponding\n        H-representation objects are those inequalities and equations\n        that are saturated on the face.\n\n        The bottom-most element of the face lattice is the \"empty\n        face\". It contains no V-representation object. All\n        H-representation objects are incident.\n\n        The top-most element is the \"full face\". It is spanned by all\n        V-representation objects. The incident H-representation\n        objects are all equations and no inequalities.\n\n        In the case of a full-dimensional polytope, the \"empty face\"\n        and the \"full face\" are the empty set (no vertices, all\n        inequalities) and the full polytope (all vertices, no\n        inequalities), respectively.\n\n        ALGORITHM:\n\n        See :mod:`sage.geometry.polyhedron.combinatorial_polyhedron.face_iterator`.\n\n        .. NOTE::\n\n            The face lattice is not cached, as long as this creates a memory leak, see :trac:`28982`.\n\n        EXAMPLES::\n\n            sage: square = polytopes.hypercube(2)\n            sage: fl = square.face_lattice();fl\n            Finite lattice containing 10 elements\n            sage: list(f.ambient_V_indices() for f in fl)\n            [(), (0,), (1,), (0, 1), (2,), (1, 2), (3,), (0, 3), (2, 3), (0, 1, 2, 3)]\n            sage: poset_element = fl[5]\n            sage: a_face = poset_element\n            sage: a_face\n            A 1-dimensional face of a Polyhedron in ZZ^2 defined as the convex hull of 2 vertices\n            sage: a_face.ambient_V_indices()\n            (1, 2)\n            sage: set(a_face.ambient_Vrepresentation()) == \\\n            ....: set([square.Vrepresentation(1), square.Vrepresentation(2)])\n            True\n            sage: a_face.ambient_Vrepresentation()\n            (A vertex at (1, 1), A vertex at (-1, 1))\n            sage: a_face.ambient_Hrepresentation()\n            (An inequality (0, -1) x + 1 >= 0,)\n\n        A more complicated example::\n\n            sage: c5_10 = Polyhedron(vertices = [[i,i^2,i^3,i^4,i^5] for i in range(1,11)])\n            sage: c5_10_fl = c5_10.face_lattice()\n            sage: [len(x) for x in c5_10_fl.level_sets()]\n            [1, 10, 45, 100, 105, 42, 1]\n\n        Note that if the polyhedron contains lines then there is a\n        dimension gap between the empty face and the first non-empty\n        face in the face lattice::\n\n            sage: line = Polyhedron(vertices=[(0,)], lines=[(1,)])\n            sage: [ fl.dim() for fl in line.face_lattice() ]\n            [-1, 1]\n\n        TESTS::\n\n            sage: c5_20 = Polyhedron(vertices = [[i,i^2,i^3,i^4,i^5]\n            ....:     for i in range(1,21)])\n            sage: c5_20_fl = c5_20.face_lattice() # long time\n            sage: [len(x) for x in c5_20_fl.level_sets()] # long time\n            [1, 20, 190, 580, 680, 272, 1]\n            sage: polytopes.hypercube(2).face_lattice().plot()  # optional - sage.plot\n            Graphics object consisting of 27 graphics primitives\n            sage: level_sets = polytopes.cross_polytope(2).face_lattice().level_sets()\n            sage: level_sets[0][0].ambient_V_indices(), level_sets[-1][0].ambient_V_indices()\n            ((), (0, 1, 2, 3))\n\n        Various degenerate polyhedra::\n\n            sage: [[ls.ambient_V_indices() for ls in lss] for lss in Polyhedron(vertices=[[0,0,0],[1,0,0],[0,1,0]]).face_lattice().level_sets()]\n            [[()], [(0,), (1,), (2,)], [(0, 1), (0, 2), (1, 2)], [(0, 1, 2)]]\n            sage: [[ls.ambient_V_indices() for ls in lss] for lss in Polyhedron(vertices=[(1,0,0),(0,1,0)], rays=[(0,0,1)]).face_lattice().level_sets()]\n            [[()], [(1,), (2,)], [(0, 1), (0, 2), (1, 2)], [(0, 1, 2)]]\n            sage: [[ls.ambient_V_indices() for ls in lss] for lss in Polyhedron(rays=[(1,0,0),(0,1,0)], vertices=[(0,0,1)]).face_lattice().level_sets()]\n            [[()], [(0,)], [(0, 1), (0, 2)], [(0, 1, 2)]]\n            sage: [[ls.ambient_V_indices() for ls in lss] for lss in Polyhedron(rays=[(1,0),(0,1)], vertices=[(0,0)]).face_lattice().level_sets()]\n            [[()], [(0,)], [(0, 1), (0, 2)], [(0, 1, 2)]]\n            sage: [[ls.ambient_V_indices() for ls in lss] for lss in Polyhedron(vertices=[(1,),(0,)]).face_lattice().level_sets()]\n            [[()], [(0,), (1,)], [(0, 1)]]\n            sage: [[ls.ambient_V_indices() for ls in lss] for lss in Polyhedron(vertices=[(1,0,0),(0,1,0)], lines=[(0,0,1)]).face_lattice().level_sets()]\n            [[()], [(0, 1), (0, 2)], [(0, 1, 2)]]\n            sage: [[ls.ambient_V_indices() for ls in lss] for lss in Polyhedron(lines=[(1,0,0)], vertices=[(0,0,1)]).face_lattice().level_sets()]\n            [[()], [(0, 1)]]\n            sage: [[ls.ambient_V_indices() for ls in lss] for lss in Polyhedron(lines=[(1,0),(0,1)], vertices=[(0,0)]).face_lattice().level_sets()]\n            [[()], [(0, 1, 2)]]\n            sage: [[ls.ambient_V_indices() for ls in lss] for lss in Polyhedron(lines=[(1,0)], rays=[(0,1)], vertices=[(0,0)]).face_lattice().level_sets()]\n            [[()], [(0, 1)], [(0, 1, 2)]]\n            sage: [[ls.ambient_V_indices() for ls in lss] for lss in Polyhedron(vertices=[(0,)], lines=[(1,)]).face_lattice().level_sets()]\n            [[()], [(0, 1)]]\n            sage: [[ls.ambient_V_indices() for ls in lss] for lss in Polyhedron(lines=[(1,0)], vertices=[(0,0)]).face_lattice().level_sets()]\n            [[()], [(0, 1)]]\n\n        \"\"\"\n        from sage.combinat.posets.lattices import FiniteLatticePoset\n        return FiniteLatticePoset(self.hasse_diagram())\n\n    @cached_method\n    def hasse_diagram(self):\n        r\"\"\"\n        Return the Hasse diagram of the face lattice of ``self``.\n\n        This is the Hasse diagram of the poset of the faces of ``self``.\n\n        OUTPUT: a directed graph\n\n        EXAMPLES::\n\n            sage: P = polytopes.regular_polygon(4).pyramid()                    # optional - sage.rings.number_field\n            sage: D = P.hasse_diagram(); D                                      # optional - sage.rings.number_field\n            Digraph on 20 vertices\n            sage: D.degree_polynomial()                                         # optional - sage.rings.number_field\n            x^5 + x^4*y + x*y^4 + y^5 + 4*x^3*y + 8*x^2*y^2 + 4*x*y^3\n\n        Faces of an mutable polyhedron are not hashable. Hence those are not suitable as\n        vertices of the hasse diagram. Use the combinatorial polyhedron instead::\n\n            sage: P = polytopes.regular_polygon(4).pyramid()                    # optional - sage.rings.number_field\n            sage: parent = P.parent()                                           # optional - sage.rings.number_field\n            sage: parent = parent.change_ring(QQ, backend='ppl')                # optional - sage.rings.number_field\n            sage: Q = parent._element_constructor_(P, mutable=True)             # optional - sage.rings.number_field\n            sage: Q.hasse_diagram()                                             # optional - sage.rings.number_field\n            Traceback (most recent call last):\n            ...\n            TypeError: mutable polyhedra are unhashable\n            sage: C = Q.combinatorial_polyhedron()                              # optional - sage.rings.number_field\n            sage: D = C.hasse_diagram()                                         # optional - sage.rings.number_field\n            sage: set(D.vertices()) == set(range(20))                           # optional - sage.rings.number_field\n            True\n            sage: def index_to_combinatorial_face(n):\n            ....:     return C.face_by_face_lattice_index(n)\n            sage: D.relabel(index_to_combinatorial_face, inplace=True)          # optional - sage.rings.number_field\n            sage: D.vertices()                                                  # optional - sage.rings.number_field\n            [A -1-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 0-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 0-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 0-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 0-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 0-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 1-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 1-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 1-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 1-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 1-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 1-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 1-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 1-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 2-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 2-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 2-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 2-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 2-dimensional face of a 3-dimensional combinatorial polyhedron,\n             A 3-dimensional face of a 3-dimensional combinatorial polyhedron]\n            sage: D.degree_polynomial()                                         # optional - sage.rings.number_field\n            x^5 + x^4*y + x*y^4 + y^5 + 4*x^3*y + 8*x^2*y^2 + 4*x*y^3\n        \"\"\"\n\n        from sage.geometry.polyhedron.face import combinatorial_face_to_polyhedral_face\n        C = self.combinatorial_polyhedron()\n        D = C.hasse_diagram()\n\n        def index_to_polyhedron_face(n):\n            return combinatorial_face_to_polyhedral_face(\n                    self, C.face_by_face_lattice_index(n))\n\n        return D.relabel(index_to_polyhedron_face, inplace=False, immutable=True)\n\n    def flag_f_vector(self, *args):\n        r\"\"\"\n        Return the flag f-vector.\n\n        For each `-1 < i_0 < \\dots < i_n < d` the flag f-vector\n        counts the number of flags `F_0 \\subset \\dots \\subset F_n`\n        with `F_j` of dimension `i_j` for each `0 \\leq j \\leq n`,\n        where `d` is the dimension of the polyhedron.\n\n        INPUT:\n\n        - ``args`` -- integers (optional); specify an entry of the\n          flag-f-vector; must be an increasing sequence of integers\n\n        OUTPUT:\n\n        - a dictionary, if no arguments were given\n\n        - an Integer, if arguments were given\n\n        EXAMPLES:\n\n        Obtain the entire flag-f-vector::\n\n            sage: P = polytopes.twenty_four_cell()\n            sage: P.flag_f_vector()\n                {(-1,): 1,\n                 (0,): 24,\n                 (0, 1): 192,\n                 (0, 1, 2): 576,\n                 (0, 1, 2, 3): 1152,\n                 (0, 1, 3): 576,\n                 (0, 2): 288,\n                 (0, 2, 3): 576,\n                 (0, 3): 144,\n                 (1,): 96,\n                 (1, 2): 288,\n                 (1, 2, 3): 576,\n                 (1, 3): 288,\n                 (2,): 96,\n                 (2, 3): 192,\n                 (3,): 24,\n                 (4,): 1}\n\n        Specify an entry::\n\n            sage: P.flag_f_vector(0,3)\n            144\n            sage: P.flag_f_vector(2)\n            96\n\n        Leading ``-1`` and trailing entry of dimension are allowed::\n\n            sage: P.flag_f_vector(-1,0,3)\n            144\n            sage: P.flag_f_vector(-1,0,3,4)\n            144\n\n        One can get the number of trivial faces::\n\n            sage: P.flag_f_vector(-1)\n            1\n            sage: P.flag_f_vector(4)\n            1\n\n        Polyhedra with lines, have ``0`` entries accordingly::\n\n            sage: P = (Polyhedron(lines=[[1]]) * polytopes.cross_polytope(3))\n            sage: P.flag_f_vector()\n            {(-1,): 1,\n             (0, 1): 0,\n             (0, 1, 2): 0,\n             (0, 1, 3): 0,\n             (0, 2): 0,\n             (0, 2, 3): 0,\n             (0, 3): 0,\n             (0,): 0,\n             (1, 2): 24,\n             (1, 2, 3): 48,\n             (1, 3): 24,\n             (1,): 6,\n             (2, 3): 24,\n             (2,): 12,\n             (3,): 8,\n             4: 1}\n\n        If the arguments are not stricly increasing or out of range, a key error is raised::\n\n            sage: P.flag_f_vector(-1,0,3,6)\n            Traceback (most recent call last):\n            ...\n            KeyError: (0, 3, 6)\n            sage: P.flag_f_vector(-1,3,0)\n            Traceback (most recent call last):\n            ...\n            KeyError: (3, 0)\n        \"\"\"\n        flag = self._flag_f_vector()\n        if len(args) == 0:\n            return flag\n        elif len(args) == 1:\n            return flag[(args[0],)]\n        else:\n            dim = self.dimension()\n            if args[0] == -1:\n                args = args[1:]\n            if args[-1] == dim:\n                args = args[:-1]\n            return flag[tuple(args)]\n\n    @cached_method(do_pickle=True)\n    def _flag_f_vector(self):\n        r\"\"\"\n        Return the flag-f-vector.\n\n        See :meth:`flag_f_vector`.\n\n        TESTS::\n\n            sage: polytopes.hypercube(4)._flag_f_vector()\n            {(-1,): 1,\n            (0,): 16,\n            (0, 1): 64,\n            (0, 1, 2): 192,\n            (0, 1, 2, 3): 384,\n            (0, 1, 3): 192,\n            (0, 2): 96,\n            (0, 2, 3): 192,\n            (0, 3): 64,\n            (1,): 32,\n            (1, 2): 96,\n            (1, 2, 3): 192,\n            (1, 3): 96,\n            (2,): 24,\n            (2, 3): 48,\n            (3,): 8,\n            (4,): 1}\n        \"\"\"\n        return self.combinatorial_polyhedron()._flag_f_vector()\n\n    @cached_method\n    def combinatorial_automorphism_group(self, vertex_graph_only=False):\n        \"\"\"\n        Computes the combinatorial automorphism group.\n\n        If ``vertex_graph_only`` is ``True``,  the automorphism group\n        of the vertex-edge graph of the polyhedron is returned. Otherwise\n        the automorphism group of the vertex-facet graph, which is\n        isomorphic to the automorphism group of the face lattice is returned.\n\n        INPUT:\n\n        - ``vertex_graph_only`` -- boolean (default: ``False``); whether\n          to return the automorphism group of the vertex edges graph or\n          of the lattice\n\n        OUTPUT:\n\n        A\n        :class:`PermutationGroup<sage.groups.perm_gps.permgroup.PermutationGroup_generic_with_category'>`\n        that is isomorphic to the combinatorial automorphism group is\n        returned.\n\n        - if ``vertex_graph_only`` is ``True``:\n          The automorphism group of the vertex-edge graph of the polyhedron\n\n        - if ``vertex_graph_only`` is ``False`` (default):\n          The automorphism group of the vertex-facet graph of the polyhedron,\n          see :meth:`vertex_facet_graph`. This group is isomorphic to the\n          automorphism group of the face lattice of the polyhedron.\n\n        NOTE:\n\n            Depending on ``vertex_graph_only``, this method returns groups\n            that are not necessarily isomorphic, see the examples below.\n\n        .. SEEALSO::\n\n            :meth:`is_combinatorially_isomorphic`,\n            :meth:`graph`,\n            :meth:`vertex_facet_graph`.\n\n        EXAMPLES::\n\n            sage: quadrangle = Polyhedron(vertices=[(0,0),(1,0),(0,1),(2,3)])\n            sage: quadrangle.combinatorial_automorphism_group().is_isomorphic(groups.permutation.Dihedral(4))\n            True\n            sage: quadrangle.restricted_automorphism_group()\n            Permutation Group with generators [()]\n\n        Permutations of the vertex graph only exchange vertices with vertices::\n\n            sage: P = Polyhedron(vertices=[(1,0), (1,1)], rays=[(1,0)])\n            sage: P.combinatorial_automorphism_group(vertex_graph_only=True)\n            Permutation Group with generators [(A vertex at (1,0),A vertex at (1,1))]\n\n        This shows an example of two polytopes whose vertex-edge graphs are isomorphic,\n        but their face_lattices are not isomorphic::\n\n            sage: Q=Polyhedron([[-123984206864/2768850730773, -101701330976/922950243591, -64154618668/2768850730773, -2748446474675/2768850730773],\n            ....: [-11083969050/98314591817, -4717557075/98314591817, -32618537490/98314591817, -91960210208/98314591817],\n            ....: [-9690950/554883199, -73651220/554883199, 1823050/554883199, -549885101/554883199], [-5174928/72012097, 5436288/72012097, -37977984/72012097, 60721345/72012097],\n            ....: [-19184/902877, 26136/300959, -21472/902877, 899005/902877], [53511524/1167061933, 88410344/1167061933, 621795064/1167061933, 982203941/1167061933],\n            ....: [4674489456/83665171433, -4026061312/83665171433, 28596876672/83665171433, -78383796375/83665171433], [857794884940/98972360190089, -10910202223200/98972360190089, 2974263671400/98972360190089, -98320463346111/98972360190089]])\n            sage: C = polytopes.cyclic_polytope(4,8)\n            sage: C.is_combinatorially_isomorphic(Q)\n            False\n            sage: C.combinatorial_automorphism_group(vertex_graph_only=True).is_isomorphic(Q.combinatorial_automorphism_group(vertex_graph_only=True))\n            True\n            sage: C.combinatorial_automorphism_group(vertex_graph_only=False).is_isomorphic(Q.combinatorial_automorphism_group(vertex_graph_only=False))\n            False\n\n        The automorphism group of the face lattice is isomorphic to the combinatorial automorphism group::\n\n            sage: CG = C.hasse_diagram().automorphism_group()\n            sage: C.combinatorial_automorphism_group().is_isomorphic(CG)\n            True\n            sage: QG = Q.hasse_diagram().automorphism_group()\n            sage: Q.combinatorial_automorphism_group().is_isomorphic(QG)\n            True\n\n        \"\"\"\n        if vertex_graph_only:\n            G = self.graph()\n        else:\n            G = self.vertex_facet_graph()\n        return G.automorphism_group(edge_labels=True)\n\n    @cached_method\n    def restricted_automorphism_group(self, output=\"abstract\"):\n        r\"\"\"\n        Return the restricted automorphism group.\n\n        First, let the linear automorphism group be the subgroup of\n        the affine group `AGL(d,\\RR) = GL(d,\\RR) \\ltimes \\RR^d`\n        preserving the `d`-dimensional polyhedron. The affine group\n        acts in the usual way `\\vec{x}\\mapsto A\\vec{x}+b` on the\n        ambient space.\n\n        The restricted automorphism group is the subgroup of the linear\n        automorphism group generated by permutations of the generators\n        of the same type. That is, vertices can only be permuted with\n        vertices, ray generators with ray generators, and line\n        generators with line generators.\n\n        For example, take the first quadrant\n\n        .. MATH::\n\n            Q = \\Big\\{ (x,y) \\Big| x\\geq 0,\\; y\\geq0 \\Big\\}\n            \\subset \\QQ^2\n\n        Then the linear automorphism group is\n\n        .. MATH::\n\n            \\mathrm{Aut}(Q) =\n            \\left\\{\n            \\begin{pmatrix}\n            a & 0 \\\\ 0 & b\n            \\end{pmatrix}\n            ,~\n            \\begin{pmatrix}\n            0 & c \\\\ d & 0\n            \\end{pmatrix}\n            :~\n            a, b, c, d \\in \\QQ_{>0}\n            \\right\\}\n            \\subset\n            GL(2,\\QQ)\n            \\subset\n            E(d)\n\n        Note that there are no translations that map the quadrant `Q`\n        to itself, so the linear automorphism group is contained in\n        the general linear group (the subgroup of transformations\n        preserving the origin). The restricted automorphism group is\n\n        .. MATH::\n\n            \\mathrm{Aut}(Q) =\n            \\left\\{\n            \\begin{pmatrix}\n            1 & 0 \\\\ 0 & 1\n            \\end{pmatrix}\n            ,~\n            \\begin{pmatrix}\n            0 & 1 \\\\ 1 & 0\n            \\end{pmatrix}\n            \\right\\}\n            \\simeq \\ZZ_2\n\n        INPUT:\n\n        - ``output`` -- how the group should be represented:\n\n          - ``\"abstract\"`` (default) -- return an abstract permutation\n            group without further meaning.\n\n          - ``\"permutation\"`` -- return a permutation group on the\n            indices of the polyhedron generators. For example, the\n            permutation ``(0,1)`` would correspond to swapping\n            ``self.Vrepresentation(0)`` and ``self.Vrepresentation(1)``.\n\n          - ``\"matrix\"`` -- return a matrix group representing affine\n            transformations. When acting on affine vectors, you should\n            append a `1` to every vector. If the polyhedron is not full\n            dimensional, the returned matrices act as the identity on\n            the orthogonal complement of the affine space spanned by\n            the polyhedron.\n\n          - ``\"matrixlist\"`` -- like ``matrix``, but return the list of\n            elements of the matrix group. Useful for fields without a\n            good implementation of matrix groups or to avoid the\n            overhead of creating the group.\n\n        OUTPUT:\n\n        - For ``output=\"abstract\"`` and ``output=\"permutation\"``:\n          a :class:`PermutationGroup<sage.groups.perm_gps.permgroup.PermutationGroup_generic>`.\n\n        - For ``output=\"matrix\"``: a :class:`MatrixGroup`.\n\n        - For ``output=\"matrixlist\"``: a list of matrices.\n\n        REFERENCES:\n\n        - [BSS2009]_\n\n        EXAMPLES:\n\n        A cross-polytope example::\n\n            sage: P = polytopes.cross_polytope(3)\n            sage: P.restricted_automorphism_group() == PermutationGroup([[(3,4)], [(2,3),(4,5)],[(2,5)],[(1,2),(5,6)],[(1,6)]])\n            True\n            sage: P.restricted_automorphism_group(output=\"permutation\") == PermutationGroup([[(2,3)],[(1,2),(3,4)],[(1,4)],[(0,1),(4,5)],[(0,5)]])\n            True\n            sage: mgens = [[[1,0,0,0],[0,1,0,0],[0,0,-1,0],[0,0,0,1]], [[1,0,0,0],[0,0,1,0],[0,1,0,0],[0,0,0,1]], [[0,1,0,0],[1,0,0,0],[0,0,1,0],[0,0,0,1]]]\n\n        We test groups for equality in a fool-proof way; they can have different generators, etc::\n\n            sage: poly_g = P.restricted_automorphism_group(output=\"matrix\")\n            sage: matrix_g = MatrixGroup([matrix(QQ,t) for t in mgens])\n            sage: all(t.matrix() in poly_g for t in matrix_g.gens())\n            True\n            sage: all(t.matrix() in matrix_g for t in poly_g.gens())\n            True\n\n        24-cell example::\n\n            sage: P24 = polytopes.twenty_four_cell()\n            sage: AutP24 = P24.restricted_automorphism_group()\n            sage: PermutationGroup([\n            ....:     '(1,20,2,24,5,23)(3,18,10,19,4,14)(6,21,11,22,7,15)(8,12,16,17,13,9)',\n            ....:     '(1,21,8,24,4,17)(2,11,6,15,9,13)(3,20)(5,22)(10,16,12,23,14,19)'\n            ....: ]).is_isomorphic(AutP24)\n            True\n            sage: AutP24.order()\n            1152\n\n        Here is the quadrant example mentioned in the beginning::\n\n            sage: P = Polyhedron(rays=[(1,0),(0,1)])\n            sage: P.Vrepresentation()\n            (A vertex at (0, 0), A ray in the direction (0, 1), A ray in the direction (1, 0))\n            sage: P.restricted_automorphism_group(output=\"permutation\")\n            Permutation Group with generators [(1,2)]\n\n        Also, the polyhedron need not be full-dimensional::\n\n            sage: P = Polyhedron(vertices=[(1,2,3,4,5),(7,8,9,10,11)])\n            sage: P.restricted_automorphism_group()\n            Permutation Group with generators [(1,2)]\n            sage: G = P.restricted_automorphism_group(output=\"matrixlist\")\n            sage: G\n            (\n            [1 0 0 0 0 0]  [ -87/55  -82/55    -2/5   38/55   98/55   12/11]\n            [0 1 0 0 0 0]  [-142/55  -27/55    -2/5   38/55   98/55   12/11]\n            [0 0 1 0 0 0]  [-142/55  -82/55     3/5   38/55   98/55   12/11]\n            [0 0 0 1 0 0]  [-142/55  -82/55    -2/5   93/55   98/55   12/11]\n            [0 0 0 0 1 0]  [-142/55  -82/55    -2/5   38/55  153/55   12/11]\n            [0 0 0 0 0 1], [      0       0       0       0       0       1]\n            )\n            sage: g = AffineGroup(5, QQ)(G[1])\n            sage: g\n                  [ -87/55  -82/55    -2/5   38/55   98/55]     [12/11]\n                  [-142/55  -27/55    -2/5   38/55   98/55]     [12/11]\n            x |-> [-142/55  -82/55     3/5   38/55   98/55] x + [12/11]\n                  [-142/55  -82/55    -2/5   93/55   98/55]     [12/11]\n                  [-142/55  -82/55    -2/5   38/55  153/55]     [12/11]\n            sage: g^2\n                  [1 0 0 0 0]     [0]\n                  [0 1 0 0 0]     [0]\n            x |-> [0 0 1 0 0] x + [0]\n                  [0 0 0 1 0]     [0]\n                  [0 0 0 0 1]     [0]\n            sage: g(list(P.vertices()[0]))\n            (7, 8, 9, 10, 11)\n            sage: g(list(P.vertices()[1]))\n            (1, 2, 3, 4, 5)\n\n        Affine transformations do not change the restricted automorphism\n        group. For example, any non-degenerate triangle has the\n        dihedral group with 6 elements, `D_6`, as its automorphism\n        group::\n\n            sage: initial_points = [vector([1,0]), vector([0,1]), vector([-2,-1])]\n            sage: points = initial_points\n            sage: Polyhedron(vertices=points).restricted_automorphism_group()\n            Permutation Group with generators [(2,3), (1,2)]\n            sage: points = [pt - initial_points[0] for pt in initial_points]\n            sage: Polyhedron(vertices=points).restricted_automorphism_group()\n            Permutation Group with generators [(2,3), (1,2)]\n            sage: points = [pt - initial_points[1] for pt in initial_points]\n            sage: Polyhedron(vertices=points).restricted_automorphism_group()\n            Permutation Group with generators [(2,3), (1,2)]\n            sage: points = [pt - 2*initial_points[1] for pt in initial_points]\n            sage: Polyhedron(vertices=points).restricted_automorphism_group()\n            Permutation Group with generators [(2,3), (1,2)]\n\n        The ``output=\"matrixlist\"`` can be used over fields without a\n        complete implementation of matrix groups::\n\n            sage: P = polytopes.dodecahedron(); P\n            A 3-dimensional polyhedron in (Number Field in sqrt5 with defining polynomial x^2 - 5 with sqrt5 = 2.236067977499790?)^3 defined as the convex hull of 20 vertices\n            sage: G = P.restricted_automorphism_group(output=\"matrixlist\")\n            sage: len(G)\n            120\n\n        Floating-point computations are supported with a simple fuzzy\n        zero implementation::\n\n            sage: P = Polyhedron(vertices=[(1/3,0,0,1),(0,1/4,0,1),(0,0,1/5,1)], base_ring=RDF)\n            sage: P.restricted_automorphism_group()\n            Permutation Group with generators [(2,3), (1,2)]\n            sage: len(P.restricted_automorphism_group(output=\"matrixlist\"))\n            6\n\n        TESTS::\n\n            sage: P = Polyhedron(vertices=[(1,0), (1,1)], rays=[(1,0)])\n            sage: P.restricted_automorphism_group(output=\"permutation\")\n            Permutation Group with generators [(1,2)]\n            sage: P.restricted_automorphism_group(output=\"matrix\")\n            Matrix group over Rational Field with 1 generators (\n            [ 1  0  0]\n            [ 0 -1  1]\n            [ 0  0  1]\n            )\n            sage: P.restricted_automorphism_group(output=\"foobar\")\n            Traceback (most recent call last):\n            ...\n            ValueError: unknown output 'foobar', valid values are ('abstract', 'permutation', 'matrix', 'matrixlist')\n\n        Check that :trac:`28828` is fixed::\n\n            sage: P.restricted_automorphism_group(output=\"matrixlist\")[0].is_immutable()\n            True\n        \"\"\"\n        # The algorithm works as follows:\n        #\n        # Let V be the matrix where every column is a homogeneous\n        # coordinate of a V-representation object (vertex, ray, line).\n        # Let us assume that V has full rank, that the polyhedron is\n        # full dimensional.\n        #\n        # Let Q = V Vt and C = Vt Q^-1 V. The rows and columns of C\n        # can be thought of as being indexed by the V-rep objects of the\n        # polytope.\n        #\n        # It turns out that we can identify the restricted automorphism\n        # group with the automorphism group of the edge-colored graph\n        # on the V-rep objects with colors determined by the symmetric\n        # matrix C.\n        #\n        # An automorphism of this graph is equivalent to a permutation\n        # matrix P such that C = Pt C P. If we now define\n        # A = V P Vt Q^-1, then one can check that V P = A V.\n        # In other words: permuting the generators is the same as\n        # applying the affine transformation A on the generators.\n        #\n        # If the given polyhedron is not fully-dimensional,\n        # then Q will be not invertible. In this case, we use a\n        # pseudoinverse Q+ instead of Q^-1. The formula for A acting on\n        # the space spanned by V then simplifies to A = V P V+ where V+\n        # denotes the pseudoinverse of V, which also equals V+ = Vt Q+.\n        #\n        # If we are asked to return the (group of) transformation\n        # matrices to the user, we also require that those\n        # transformations act as the identity on the orthogonal\n        # complement of the space spanned by V. This complement is the\n        # space spanned by the columns of W = 1 - V V+. One can check\n        # that B = (V P V+) + W is the correct matrix: it acts the same\n        # as A on V and it satisfies B W = W.\n\n        outputs = (\"abstract\", \"permutation\", \"matrix\", \"matrixlist\")\n        if output not in outputs:\n            raise ValueError(\"unknown output {!r}, valid values are {}\".format(output, outputs))\n\n        # For backwards compatibility, we treat \"abstract\" as\n        # \"permutation\", but where we add 1 to the indices of the\n        # permutations.\n        index0 = 0\n        if output == \"abstract\":\n            index0 = 1\n            output = \"permutation\"\n\n        if self.base_ring().is_exact():\n            def rational_approximation(c):\n                return c\n        else:\n            c_list = []\n\n            def rational_approximation(c):\n                # Implementation detail: Return unique integer if two\n                # c-values are the same up to machine precision. But\n                # you can think of it as a uniquely-chosen rational\n                # approximation.\n                for i, x in enumerate(c_list):\n                    if self._is_zero(x - c):\n                        return i\n                c_list.append(c)\n                return len(c_list) - 1\n\n        if self.is_compact():\n            def edge_label(i, j, c_ij):\n                return c_ij\n        else:\n            # In the non-compact case, we also label the edges by the\n            # type of the V-representation object. This ensures that\n            # vertices, rays, and lines are only permuted amongst\n            # themselves.\n            def edge_label(i, j, c_ij):\n                return (self.Vrepresentation(i).type(), c_ij, self.Vrepresentation(j).type())\n\n        # Homogeneous coordinates for the V-representation objects.\n        # Mathematically, V is a matrix. For efficiency however, we\n        # represent it as a list of column vectors.\n        V = [v.homogeneous_vector() for v in self.Vrepresentation()]\n\n        # Pseudoinverse of V Vt\n        Qplus = sum(v.column() * v.row() for v in V).pseudoinverse()\n\n        # Construct the graph.\n        from sage.graphs.graph import Graph\n        G = Graph()\n        for i in range(len(V)):\n            for j in range(i+1, len(V)):\n                c_ij = rational_approximation(V[i] * Qplus * V[j])\n                G.add_edge(index0+i, index0+j, edge_label(i, j, c_ij))\n\n        permgroup = G.automorphism_group(edge_labels=True)\n        if output == \"permutation\":\n            return permgroup\n        elif output == \"matrix\":\n            permgroup = permgroup.gens()\n\n        # Compute V+ = Vt Q+ as list of row vectors\n        from sage.matrix.constructor import matrix\n        Vplus = list(matrix(V) * Qplus)  # matrix(V) is Vt\n\n        # Compute W = 1 - V V+\n        W = 1 - sum(V[i].column() * Vplus[i].row() for i in range(len(V)))\n\n        # Convert the permutation group to a matrix group.\n        # If P is a permutation, then we return the matrix\n        # B = (V P V+) + W.\n        #\n        # If output == \"matrix\", we loop over the generators of the group.\n        # Otherwise, we loop over all elements.\n        matrices = []\n        for perm in permgroup:\n            A = sum(V[perm(i)].column() * Vplus[i].row() for i in range(len(V)))\n            matrices.append(A + W)\n\n        for mat in matrices:\n            mat.set_immutable()\n\n        if output == \"matrixlist\":\n            return tuple(matrices)\n        else:\n            from sage.groups.matrix_gps.finitely_generated import MatrixGroup\n            return MatrixGroup(matrices)\n\n    def is_combinatorially_isomorphic(self, other, algorithm='bipartite_graph'):\n        r\"\"\"\n        Return whether the polyhedron is combinatorially isomorphic to another polyhedron.\n\n        We only consider bounded polyhedra. By definition, they are\n        combinatorially isomorphic if their face lattices are isomorphic.\n\n        INPUT:\n\n        - ``other`` -- a polyhedron object\n        - ``algorithm`` (default = ``bipartite_graph``) -- the algorithm to use.\n          The other possible value is ``face_lattice``.\n\n        OUTPUT:\n\n        - ``True`` if the two polyhedra are combinatorially isomorphic\n        - ``False`` otherwise\n\n        .. SEEALSO::\n\n            :meth:`combinatorial_automorphism_group`,\n            :meth:`vertex_facet_graph`.\n\n        REFERENCES:\n\n        For the equivalence of the two algorithms see [KK1995]_, p. 877-878\n\n        EXAMPLES:\n\n        The square is combinatorially isomorphic to the 2-dimensional cube::\n\n            sage: polytopes.hypercube(2).is_combinatorially_isomorphic(polytopes.regular_polygon(4))\n            True\n\n        All the faces of the 3-dimensional permutahedron are either\n        combinatorially isomorphic to a square or a hexagon::\n\n            sage: H = polytopes.regular_polygon(6)                              # optional - sage.rings.number_field\n            sage: S = polytopes.hypercube(2)\n            sage: P = polytopes.permutahedron(4)\n            sage: all(F.as_polyhedron().is_combinatorially_isomorphic(S)        # optional - sage.rings.number_field\n            ....:       or F.as_polyhedron().is_combinatorially_isomorphic(H)\n            ....:     for F in P.faces(2))\n            True\n\n        Checking that a regular simplex intersected with its reflection\n        through the origin is combinatorially isomorphic to the intersection\n        of a cube with a hyperplane perpendicular to its long diagonal::\n\n            sage: def simplex_intersection(k):\n            ....:   S1 = Polyhedron([vector(v)-vector(polytopes.simplex(k).center()) for v in polytopes.simplex(k).vertices_list()])\n            ....:   S2 = Polyhedron([-vector(v) for v in S1.vertices_list()])\n            ....:   return S1.intersection(S2)\n            sage: def cube_intersection(k):\n            ....:    C = polytopes.hypercube(k+1)\n            ....:    H = Polyhedron(eqns=[[0]+[1 for i in range(k+1)]])\n            ....:    return C.intersection(H)\n            sage: [simplex_intersection(k).is_combinatorially_isomorphic(cube_intersection(k)) for k in range(2,5)]\n            [True, True, True]\n            sage: simplex_intersection(2).is_combinatorially_isomorphic(polytopes.regular_polygon(6))   # optional - sage.rings.number_field\n            True\n            sage: simplex_intersection(3).is_combinatorially_isomorphic(polytopes.octahedron())\n            True\n\n        Two polytopes with the same `f`-vector, but different combinatorial types::\n\n            sage: P = Polyhedron([[-605520/1525633, -605520/1525633, -1261500/1525633, -52200/1525633, 11833/1525633],\\\n             [-720/1769, -600/1769, 1500/1769, 0, -31/1769], [-216/749, 240/749, -240/749, -432/749, 461/749], \\\n             [-50/181, 50/181, 60/181, -100/181, -119/181], [-32/51, -16/51, -4/51, 12/17, 1/17],\\\n             [1, 0, 0, 0, 0], [16/129, 128/129, 0, 0, 1/129], [64/267, -128/267, 24/89, -128/267, 57/89],\\\n             [1200/3953, -1200/3953, -1440/3953, -360/3953, -3247/3953], [1512/5597, 1512/5597, 588/5597, 4704/5597, 2069/5597]])\n            sage: C = polytopes.cyclic_polytope(5,10)\n            sage: C.f_vector() == P.f_vector(); C.f_vector()\n            True\n            (1, 10, 45, 100, 105, 42, 1)\n            sage: C.is_combinatorially_isomorphic(P)\n            False\n\n            sage: S = polytopes.simplex(3)\n            sage: S = S.face_truncation(S.faces(0)[3])\n            sage: S = S.face_truncation(S.faces(0)[4])\n            sage: S = S.face_truncation(S.faces(0)[5])\n            sage: T = polytopes.simplex(3)\n            sage: T = T.face_truncation(T.faces(0)[3])\n            sage: T = T.face_truncation(T.faces(0)[4])\n            sage: T = T.face_truncation(T.faces(0)[4])\n            sage: T.is_combinatorially_isomorphic(S)\n            False\n            sage: T.f_vector(), S.f_vector()\n            ((1, 10, 15, 7, 1), (1, 10, 15, 7, 1))\n\n            sage: C = polytopes.hypercube(5)\n            sage: C.is_combinatorially_isomorphic(C)\n            True\n            sage: C.is_combinatorially_isomorphic(C, algorithm='magic')\n            Traceback (most recent call last):\n            ...\n            AssertionError: `algorithm` must be 'bipartite graph' or 'face_lattice'\n\n            sage: G = Graph()\n            sage: C.is_combinatorially_isomorphic(G)\n            Traceback (most recent call last):\n            ...\n            AssertionError: input `other` must be a polyhedron\n\n            sage: H = Polyhedron(eqns=[[0,1,1,1,1]]); H\n            A 3-dimensional polyhedron in QQ^4 defined as the convex hull of 1 vertex and 3 lines\n            sage: C.is_combinatorially_isomorphic(H)\n            Traceback (most recent call last):\n            ...\n            AssertionError: polyhedron `other` must be bounded\n\n        \"\"\"\n        assert isinstance(other, Polyhedron_base4), \"input `other` must be a polyhedron\"\n        assert self.is_compact(), \"polyhedron `self` must be bounded\"\n        assert other.is_compact(), \"polyhedron `other` must be bounded\"\n        assert algorithm in ['bipartite_graph', 'face_lattice'], \"`algorithm` must be 'bipartite graph' or 'face_lattice'\"\n\n        # For speed, we check if the polyhedra have the same number of facets and vertices.\n        # This is faster than building the bipartite graphs first and\n        # then check that they won't be isomorphic.\n        if self.n_vertices() != other.n_vertices() or self.n_facets() != other.n_facets():\n            return False\n\n        if algorithm == 'bipartite_graph':\n            G_self = self.vertex_facet_graph(False)\n            G_other = other.vertex_facet_graph(False)\n\n            return G_self.is_isomorphic(G_other)\n        else:\n            return self.face_lattice().is_isomorphic(other.face_lattice())\n\n    def _test_is_combinatorially_isomorphic(self, tester=None, **options):\n        \"\"\"\n        Run tests on the method :meth:`.is_combinatorially_isomorphic`.\n\n        TESTS::\n\n            sage: polytopes.cross_polytope(3)._test_is_combinatorially_isomorphic()\n        \"\"\"\n        if tester is None:\n            tester = self._tester(**options)\n\n        if not self.is_compact():\n            with tester.assertRaises(AssertionError):\n                self.is_combinatorially_isomorphic(self)\n            return\n\n        if self.n_vertices() > 200 or self.n_facets() > 200:\n            # Avoid very long doctests.\n            return\n\n        try:\n            import sage.graphs.graph\n        except ImportError:\n            return\n\n        from sage.rings.integer_ring import ZZ\n        tester.assertTrue(self.is_combinatorially_isomorphic(ZZ(4)*self))\n        if self.n_vertices():\n            tester.assertTrue(self.is_combinatorially_isomorphic(self + self.center()))\n\n        if self.n_vertices() < 20 and self.n_facets() < 20 and self.is_immutable():\n            tester.assertTrue(self.is_combinatorially_isomorphic(ZZ(4)*self, algorithm='face_lattice'))\n            if self.n_vertices():\n                tester.assertTrue(self.is_combinatorially_isomorphic(self + self.center(), algorithm='face_lattice'))\n\n    def is_self_dual(self):\n        r\"\"\"\n        Return whether the polytope is self-dual.\n\n        A polytope is self-dual if its face lattice is isomorphic to the face\n        lattice of its dual polytope.\n\n        EXAMPLES::\n\n            sage: polytopes.simplex().is_self_dual()\n            True\n            sage: polytopes.twenty_four_cell().is_self_dual()\n            True\n            sage: polytopes.cube().is_self_dual()\n            False\n            sage: polytopes.hypersimplex(5,2).is_self_dual()\n            False\n            sage: P = Polyhedron(vertices=[[1/2, 1/3]], rays=[[1, 1]]).is_self_dual()\n            Traceback (most recent call last):\n            ...\n            ValueError: polyhedron has to be compact\n\n        \"\"\"\n        if not self.is_compact():\n            raise ValueError(\"polyhedron has to be compact\")\n\n        n = self.n_vertices()\n        m = self.n_facets()\n        if n != m:\n            return False\n\n        G1 = self.vertex_facet_graph()\n        G2 = G1.reverse()\n        return G1.is_isomorphic(G2)\n", "meta": {"hexsha": "8c7dd0c2836a2c8c24a3defb8bbec8e4c93c801b", "size": 51858, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/geometry/polyhedron/base4.py", "max_stars_repo_name": "LaisRast/sage", "max_stars_repo_head_hexsha": "5fb2a6ea44400e469caee82748cf863ca0c5f724", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/sage/geometry/polyhedron/base4.py", "max_issues_repo_name": "LaisRast/sage", "max_issues_repo_head_hexsha": "5fb2a6ea44400e469caee82748cf863ca0c5f724", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/geometry/polyhedron/base4.py", "max_forks_repo_name": "LaisRast/sage", "max_forks_repo_head_hexsha": "5fb2a6ea44400e469caee82748cf863ca0c5f724", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.6195826645, "max_line_length": 245, "alphanum_fraction": 0.563191793, "include": true, "reason": "import sage,from sage", "num_tokens": 13806, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4726834766204328, "lm_q2_score": 0.11920293140927592, "lm_q1q2_score": 0.05634525604188353}}
{"text": "# %%\n\"\"\"\n.. _04-create-a-2d-dnpdata-object-from-individual-spectra:\n\n=======================================================\n04 - Create a 2D dnpdata Object from Individual Spectra\n=======================================================\n\nThis example demonstrates how to import a list of DNP-NMR spectra and create a 2D dnpdata object.\n\nDepending on how you record a set of DNP-NMR experiments, you will either end up with a single file corresponding to a 2D array of spectra (in which case you can skip to the next example ...) or with a set of individual files. A common example is recording the DNP enhancement as a function of the microwave power. For easy data handling, these individual spectra can be concatanated in a single dnpdata object for easy processing and analyzing of the data.\n\"\"\"\n# %%\n# Load NMR Spectra\n# ----------------\n# For this example a set of 1D NMR spectra is imported. Each spectrum is recorded using a different microwave power. The import function of DNPLab can handle a list of spectra and will automatically create the dnpdata object. To load multiple spectra first create a list of paths to the individual spectra (alternatively, you can loop over the folder index, however, for educational purposes we keep this simple for now). \nimport dnplab as dnp\nimport numpy as np\n\nfilenames = [\n    \"../data/prospa/toluene_10mM_Tempone/1/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/2/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/3/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/4/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/5/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/6/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/7/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/8/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/9/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/10/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/11/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/12/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/13/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/14/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/15/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/16/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/17/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/18/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/19/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/20/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/21/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/22/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/23/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/24/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/25/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/26/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/27/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/28/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/29/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/30/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/31/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/32/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/33/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/34/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/35/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/36/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/37/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/38/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/39/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/40/data.1d\",\n    \"../data/prospa/toluene_10mM_Tempone/41/data.1d\",\n]\n\n# %%\n# Create an array with the power levels. The length of this array should match the number of spectra. The Python list \"filenames\" and the array of power levels will become input arguments to the load function. Here, the dimension is called \"Power\" and the values stored in \"powers\" serves as the \"coord\" input argument. When importing the spectra DNPLab will automatically create a 2D object with a new dimension namend \"Power\" and the data is concatenated into a single 2D dnpdata object.\npowers = np.array([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40])   # Power in dBm\n\n# %%\n# Now load the data and assign the power array to coord,\ndata = dnp.dnpImport.load(filenames, dim = \"Power\", coord = powers)\n\n# %%\n# Finally, we can create the workspace, add the data to the \"raw\" object, and copy the \"raw\" data to the processing buffer.\nws = dnp.create_workspace()\nws.add(\"raw\", data)\nws.copy(\"raw\", \"proc\")\n\n# %%\n# Process and Save the NMR Spectra\n# --------------------------------\n# Once the 2D data set is created, NMR processing is straightforward. Here, we apply a line-broadening of 10 Hz, perform a Fourier Transformation, and zero-filling of the data set to twice the number of points.\ndnp.dnpNMR.remove_offset(ws)\ndnp.dnpNMR.window(ws, linewidth = 10)\ndnp.dnpNMR.fourier_transform(ws, zero_fill_factor = 2)\n\n# %%\n# Finally, the 1D spectra are plotted.\ndnp.dnpResults.figure()\ndnp.dnpResults.plot(ws[\"proc\"].real)\ndnp.dnpResults.xlim([30, -30])\ndnp.dnpResults.plt.xlabel(\"Chemical Shift [ppm]\")\ndnp.dnpResults.plt.ylabel(\"Signal Amplitude [a.u.]\")\ndnp.dnpResults.plt.title(\"DNP Enhancement Power Build-Up, 10 mM TEMPO in Toluene\")\ndnp.dnpResults.plt.grid(True)\ndnp.dnpResults.show()\n\n# %%\n# Saving the Processed Data\n# -------------------------\n# DNPLab has built-in capabilities to save large data sets, so we can save the already concatenated and processed NMR data in a single file and load just this file for further processing.\n\nfile_name_path = \"../data/h5/PowerBuildUp.h5\"\ndnp.dnpSave.save(ws,file_name_path, overwrite = True)\n\n# %%\n# DNPLab saves the 2D dnpdata object in the hdf5 file format. We will use this data in the next example (:ref:`05-calculate-dnp-enhancements-i`) for further processing.\n", "meta": {"hexsha": "16e1e56458d1ea64f30e031e3d6f1e9cd5bc2082", "size": 5816, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/plot_04_create_dnpdata_object_from_individual_files.py", "max_stars_repo_name": "DNPLab/DNPLab", "max_stars_repo_head_hexsha": "78999a4e8320b6476a5aa55d9884c49d74149edc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2020-09-23T08:09:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-10T22:02:11.000Z", "max_issues_repo_path": "examples/plot_04_create_dnpdata_object_from_individual_files.py", "max_issues_repo_name": "DNPLab/DNPLab", "max_issues_repo_head_hexsha": "78999a4e8320b6476a5aa55d9884c49d74149edc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 126, "max_issues_repo_issues_event_min_datetime": "2020-09-16T22:25:59.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-29T17:15:27.000Z", "max_forks_repo_path": "examples/plot_04_create_dnpdata_object_from_individual_files.py", "max_forks_repo_name": "DNPLab/DNPLab", "max_forks_repo_head_hexsha": "78999a4e8320b6476a5aa55d9884c49d74149edc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2020-09-24T20:57:31.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-19T01:52:16.000Z", "avg_line_length": 54.3551401869, "max_line_length": 489, "alphanum_fraction": 0.7125171939, "include": true, "reason": "import numpy", "num_tokens": 1839, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46879064146934857, "lm_q2_score": 0.11920292515117027, "lm_q1q2_score": 0.05588121574663986}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# <!-- HTML file automatically generated from DocOnce source (https://github.com/doconce/doconce/)\n# doconce format html hw3.do.txt --no_mako -->\n# <!-- dom:TITLE: PHY321: Classical Mechanics 1 -->\n\n# # PHY321: Classical Mechanics 1\n# **Homework 3, due February 4**\n# \n# Date: **Jan 31, 2022**\n\n# ### Practicalities about  homeworks and projects\n# \n# 1. You can work in groups (optimal groups are often 2-3 people) or by yourself. If you work as a group you can hand in one answer only if you wish. **Remember to write your name(s)**!\n# \n# 2. Homeworks are available ten days  before the deadline. \n# \n# 3. How do I(we)  hand in?  You can hand in the paper and pencil exercises as a  scanned document. For this homework this applies to exercises 1-5. Alternatively, you can hand in everything (if you are ok with typing mathematical formulae using say Latex) as a jupyter notebook at D2L. The numerical exercise(s) (exercise 6 here) should always be handed in as a jupyter notebook by the deadline at D2L.\n\n# ### Introduction to homework 3\n# \n# This week's sets of classical pen and paper and computational\n# exercises deal with the motion of different objects under the\n# influence of various forces. The relevant reading background is\n# 1. chapter 2 of Taylor (there are many good examples there) and\n# \n# 2. chapters 5-7 of Malthe-Sørenssen.\n# \n# In both textbooks there are many nice worked out\n# examples. Malthe-Sørenssen's text contains also several coding\n# examples you may find useful.\n# \n# There are several pedagogical aims we have in mind with these exercises:\n# 1. Get practice in setting up and analyzing a physical problem, finding the forces and the relevant equations to solve;\n# \n# 2. Analyze the results and ask yourself whether they make sense or not;\n# \n# 3. Finding analytical solutions to problems if possible and compare these with numerical results. This teaches us also how to understand errors in numerical calculations;\n# \n# 4. Being able to solve (in mechanics these are the most common types of equations) numerically ordinary differential equations and compare the solutions where possible with analytical solutions;\n# \n# 5. Getting used to studying physical problems using all possible tools, from paper and pencil to numerical solutions;\n# \n# 6. Then analyze the results and ask yourself whether they make sense or not.\n# \n# The above steps outline important elements of our understanding of the\n# scientific method. Furthermore, there are also explicit coding skills\n# we aim at such as setting up arrays, solving differential equations\n# numerically and plotting your results.  Coding practice is also an\n# important aspect. The more we practice the better we get (hopefully).\n# From a numerical mathematics point of view, we will solve the differential\n# equations using Euler's method (forward Euler).\n# \n# The code we will develop can be reused as a basis for coming homeworks. We can\n# also extend the numerical solver we write here to include other methods (later) like\n# the modified Euler method (Euler-Cromer, midpoint Euler) and more\n# advanced methods like the family of Runge-Kutta methods and the Velocity-Verlet method.\n# \n# At the end of this course, we will thus have developed a larger code\n# (or set of codes) which will allow us to study different numerical\n# methods (integration and differential equations) as well as being able\n# to study different physical systems. Combined with analytical skills,\n# the hope is that this can allow us to explore interesting and\n# realistic physics problems. By doing so, the hope is that can lead to\n# deeper insights about the laws of motion which govern a system.\n# \n# And hopefully you can reuse many of the above solvers in other courses (our ideal).\n\n# ### Exercise 1 (20 pt), Electron moving into an electric field\n# \n# An electron is sent through a varying electrical\n# field. Initially, the electron is moving in the $x$-direction with a velocity\n# $v_x = 100$ m/s. The electron enters the field when it passes the origin. The field\n# varies with time, causing an acceleration of the electron that varies in time\n\n# $$\n# \\boldsymbol{a}(t)=\\left(−20 \\mathrm{m/s}^2 −10\\mathrm{m/s}^3t\\right) \\boldsymbol{e}_y\n# $$\n\n# * 1a (4pt) Find the velocity as a function of time for the electron.\n# \n# * 1b (4pt)  Find the position as a function of time for the electron.\n# \n# The field is only acting inside a box of length $L = 2m$.\n# * 1c (4pt)  How long time is the electron inside the field?\n# \n# * 1d (4pt)  What is the displacement in the $y$-direction when the electron leaves the box. (We call this the deflection of the electron).\n# \n# * 1e (4pt)  Find the angle the velocity vector forms with the horizontal axis as the electron leaves the box.\n\n# ### Exercise 2 (10 pt), Drag force\n# \n# Taylor exercise 2.3\n\n# ### Exercise 3 (10 pt), Falling object\n# \n# Taylor exercise 2.6\n\n# ### Exercise 4 (10 pt), and then a cyclist\n# \n# Taylor exercise 2.26\n\n# ### Exercise 5 (10 pt), back to a falling ball and preparing for the numerical exercise\n# \n# **Useful material: Malthe-Sørenssen chapter 7.5 and Taylor chapter 2.4.**\n# \n# In this example we study the motion of an object subject to a constant force, a velocity dependent\n# force. We will  reuse the code we develop here in homework 4 for a position-dependent force.\n# \n# Here we limit ourselves to a ball that is thrown from a height $h$\n# above the ground with an initial velocity\n# $\\boldsymbol{v}_0$ at time $t=t_0$. We assume the air resistance is proportional  to the square velocity, Together with the gravitational force these are the forces acting on our system.\n# **Note that due to the specific velocity dependence, we cannot find an analytical solution for motion in the $x$ and $y$ directions, see the discussion in Taylor after eq. (2.61).**\n# In order to find an analytical solution we need to assume that the object is falling in the $y$-direction (negative direction) only. \n# \n# The position of the ball as function of time is  $\\boldsymbol{r}(t)$ where $t$ is time.\n#  The position is measured with respect to a coordinate system with origin at the floor.\n# \n# We assume we have an initial position $\\boldsymbol{r}(t_0)=h\\boldsymbol{e}_y$ and an initial velocity $\\boldsymbol{v}_0=v_{x,0}\\boldsymbol{e}_x+v_{y,0}\\boldsymbol{e}_y$.\n# \n# In this exercise we assume the system is influenced by the gravitational force\n\n# $$\n# \\boldsymbol{G}=-mg\\boldsymbol{e}_y\n# $$\n\n# and an air resistance given by a square law\n\n# $$\n# -Dv\\boldsymbol{v}.\n# $$\n\n# The analytical expressions for velocity and position as functions of\n# time will be used to compare with the numerical results in exercise 6.\n# \n# * 5a (3pt) Identify the forces acting on the ball and set up a diagram with the forces acting on the ball. Find the acceleration of the falling ball. \n# \n# * 5b (4pt) Assume now that the object is falling only in the $y$-direction (negative direction). Integrate the acceleration from an initial time $t_0$ to a final time $t$ and find the velocity. In Taylor equations (2.52) to (2.58) you will find a very good discussion of this.\n# \n# * 5c (4pt) Find thereafter the position as function of time starting with an initial time $t_0$. Find the time it takes to hit the floor.  Here you will find it convenient to set the initial velocity in the $y$-direction to zero. Taylor equations (2.52)-(2.58) should contain all relevant information for solving this part as well.\n# \n# We will use the above analytical results in our numerical calculations in exercise 6. The analytical solution in the $y$-direction only will serve as a test for our numerical solution.\n\n# ### Exercise 6 (40pt), Numerical elements, solving exercise 5 numerically\n# \n# **This exercise should be handed in as a jupyter-notebook** at D2L. Remember to write your name(s). \n# \n# Last week we:\n# 1. Gained more practice with plotting in Python\n# \n# 2. Became familiar with arrays and representing vectors with such objects\n# \n# This week we will:\n# 1. Learn and utilize Euler's Method to find the position and the velocity\n# \n# 2. Compare analytical and computational solutions \n# \n# 3. Add additional forces to our model\n\n# In[1]:\n\n\nget_ipython().run_line_magic('matplotlib', 'inline')\n\n# let's start by importing useful packages we are familiar with\nimport numpy as np\nimport matplotlib.pyplot as plt\nget_ipython().run_line_magic('matplotlib', 'inline')\n\n\n# We will choose the following values\n# 1. mass $m=0.2$ kg\n# \n# 2. accelleration (gravity) $g=9.81$ m/s$^{2}$.\n# \n# 3. initial position is the height $h=2$ m\n# \n# 4. initial velocities $v_{x,0}=v_{y,0}=10$ m/s\n# \n# Can you find a reasonable value for the drag coefficient $D$?\n# You need also to define an initial time and \n# the step size $\\Delta t$. We can define the step size $\\Delta t$ as the difference between any\n# two neighboring values in time (time steps) that we analyze within\n# some range. It can be determined by dividing the interval we are\n# analyzing, which in our case is time $t_{\\mathrm{final}}-t_0$, by the number of steps we\n# are taking $(N)$. This gives us a step size $\\Delta t = \\dfrac{t_{\\mathrm{final}}-t_0}{N}$.\n# \n# With these preliminaries we are now ready to plot our results from exercise 5.\n# \n# * 6a (10pt) Set up arrays for time, velocity, acceleration and positions for the results from exercise 5. Define an initial and final time. Choose the final time to be the time when the ball hits the ground for the first time. Make a plot of the position and velocity as functions of time.  Here you could set the initial velocity in the $y$-direction to zero and use the result from exercise 5. Else you need to try different initial times using the result from exercise 5 as a starting guess.  It is not critical if you don't reach the ground when the initial velocity in the $y$-direction is not zero.\n# \n# We move now to the numerical solution of the differential equations as discussed in the [lecture notes](https://mhjensen.github.io/Physics321/doc/pub/motion/html/motion.html) or Malthe-Sørenssen chapter 7.5.\n# Let us remind ourselves about  Euler's Method.\n# \n# Suppose we know $f(t)$ and its derivative $f'(t)$. To find $f(t+\\Delta t)$ at the next step, $t+\\Delta t$,\n# we can consider the Taylor expansion:\n# \n# $f(t+\\Delta t) = f(t) + \\dfrac{(\\Delta t)f'(t)}{1!} + \\dfrac{(\\Delta t)^2f''(t)}{2!} + ...$\n# \n# If we ignore the $f''$ term and higher derivatives, we obtain\n# \n# $f(t+\\Delta t) \\approx f(t) + (\\Delta t)f'(t)$.\n# \n# This approximation is the basis of Euler's method, and the Taylor\n# expansion suggests that it will have errors of $O(\\Delta t^2)$.  Thus, one\n# would expect it to work better, the smaller the step size $h$ that you\n# use. In our case the step size is $\\Delta t$. \n# \n# In setting up our code we need to\n# \n# 1. Define and obtain all initial values, constants, and time to be analyzed with step sizes as done above (you can use the same values)\n# \n# 2. Calculate the velocity using $v_{i+1} = v_{i} + (\\Delta t)*a_{i}$\n# \n# 3. Calculate the position using $pos_{i+1} = r_{i} + (\\Delta t)*v_{i}$\n# \n# 4. Calculate the new acceleration $a_{i+1}$.\n# \n# 5. Repeat steps 2-4 for all time steps within a loop.\n# \n# * 6b (20 pt) Write a code which implements Euler's method and compute numerically and plot the position and velocity as functions of time for various values of $\\Delta t$. Comment your results.\n# \n# * 6c (10pt) Compare your numerically obtained positions and velocities with the analytical results from exercise 5. In order to do this, you need to take out the motion in the $x$-direction. Comment again your results.\n\n# ### Classical Mechanics Extra Credit Assignment: Scientific Writing and attending Talks\n# \n# The following gives you an opportunity to earn **five extra credit\n# points** on each of the remaining homeworks and **ten extra credit points**\n# on the midterms and finals.  This assignment also covers an aspect of\n# the scientific process that is not taught in most undergraduate\n# programs: scientific writing.  Writing scientific reports is how\n# scientist communicate their results to the rest of the field.  Knowing\n# how to assemble a well written scientific report will greatly benefit\n# you in you upper level classes, in graduate school, and in the work\n# place.\n# \n# The full information on extra credits is found at <https://github.com/mhjensen/Physics321/blob/master/doc/Homeworks/ExtraCredits/>. There you will also find examples on how to write a scientific article. \n# Below you can also find a description on how to gain extra credits by attending scientific talks.\n# \n# This assignment allows you to gain extra credit points by practicing\n# your scientific writing.  For each of the remaining homeworks you can\n# submit the specified section of a scientific report (written about the\n# numerical aspect of the homework) for five extra credit points on the\n# assignment.  For the two midterms and the final, submitting a full\n# scientific report covering the numerical analysis problem will be\n# worth ten extra points.  For credit the grader must be able to tell\n# that you put effort into the assignment (i.e. well written, well\n# formatted, etc.).  If you are unfamiliar with writing scientific\n# reports, [see the information here](https://github.com/mhjensen/Physics321/blob/master/doc/Homeworks/ExtraCredits/IntroductionScientificWriting.md)\n# \n# The following table explains what aspect of a scientific report is due\n# with which homework.  You can submit the assignment in any format you\n# like, in the same document as your homework, or in a different one.\n# Remember to cite any external references you use and include a\n# reference list.  There are no length requirements, but make sure what\n# you turn in is complete and through.  If you have any questions,\n# please contact Julie Butler at butler@frib.msu.edu.\n# \n# <table class=\"dotable\" border=\"1\">\n# <thead>\n# <tr><th align=\"center\">  HW/Project </th> <th align=\"center\">Due Date</th> <th align=\"center\">Extra Credit Assignment</th> </tr>\n# </thead>\n# <tbody>\n# <tr><td align=\"center\">   HW 3             </td> <td align=\"center\">   2-4         </td> <td align=\"center\">   Abstract                   </td> </tr>\n# <tr><td align=\"center\">   HW 4             </td> <td align=\"center\">   2-11        </td> <td align=\"center\">   Introduction               </td> </tr>\n# <tr><td align=\"center\">   HW 5             </td> <td align=\"center\">   2-18        </td> <td align=\"center\">   Methods                    </td> </tr>\n# <tr><td align=\"center\">   HW 6             </td> <td align=\"center\">   3-18        </td> <td align=\"center\">   Results and Discussion     </td> </tr>\n# <tr><td align=\"center\">   **Midterm 1**    </td> <td align=\"center\">   **3-4**     </td> <td align=\"center\">   *Full Written Report*      </td> </tr>\n# <tr><td align=\"center\">   HW 7             </td> <td align=\"center\">   3-25        </td> <td align=\"center\">   Abstract                   </td> </tr>\n# <tr><td align=\"center\">   HW 8             </td> <td align=\"center\">   4-15        </td> <td align=\"center\">   Introduction               </td> </tr>\n# <tr><td align=\"center\">   HW 9             </td> <td align=\"center\">   4-22        </td> <td align=\"center\">   Results and Discussion     </td> </tr>\n# <tr><td align=\"center\">   **Midterm 2      </td> <td align=\"center\">   ** _4-8_    </td> <td align=\"center\">   *Full Written Report*      </td> </tr>\n# <tr><td align=\"center\">   HW 10            </td> <td align=\"center\">   4-29        </td> <td align=\"center\">   Abstract                   </td> </tr>\n# <tr><td align=\"center\">   **Final**        </td> <td align=\"center\">   **5-6**     </td> <td align=\"center\">   *Full Written Report*      </td> </tr>\n# </tbody>\n# </table>\n# \n# You can also gain extra credits if you attend scientific talks.\n# This is described here.\n\n# ### Integrating Classwork With Research\n# \n# This opportunity will allow you to earn up to 5 extra credit points on a Homework per week. These points can push you above 100% or help make up for missed exercises.\n# In order to earn all points you must:\n# \n# 1. Attend an MSU research talk (recommended research oriented Clubs is  provided below)\n# \n# 2. Summarize the talk using at least 150 words\n# \n# 3. Turn in the summary along with your Homework.\n# \n# Approved talks:\n# Talks given by researchers through the following clubs:\n# * Research and Idea Sharing Enterprise (RAISE)​: Meets Wednesday Nights Society for Physics Students (SPS)​: Meets Monday Nights\n# \n# * Astronomy Club​: Meets Monday Nights\n# \n# * Facility For Rare Isotope Beam (FRIB) Seminars: ​Occur multiple times a week\n# \n# If you have any questions please consult Julie or Morten\n# \n# All the material on extra credits is at <https://github.com/mhjensen/Physics321/blob/master/doc/Homeworks/ExtraCredits/>.\n", "meta": {"hexsha": "a6172887ca3a4226c8544e48916d2c076d31d6e5", "size": 16833, "ext": "py", "lang": "Python", "max_stars_repo_path": "doc/LectureNotes/_build/jupyter_execute/hw3.py", "max_stars_repo_name": "Shield94/Physics321", "max_stars_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "doc/LectureNotes/_build/jupyter_execute/hw3.py", "max_issues_repo_name": "Shield94/Physics321", "max_issues_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "doc/LectureNotes/_build/jupyter_execute/hw3.py", "max_forks_repo_name": "Shield94/Physics321", "max_forks_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 55.3717105263, "max_line_length": 606, "alphanum_fraction": 0.7140141389, "include": true, "reason": "import numpy", "num_tokens": 4447, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.34864513533394575, "lm_q2_score": 0.16026603032235004, "lm_q1q2_score": 0.055875971831169984}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Project 3:  Implement SLAM \n# \n# ---\n# \n# ## Project Overview\n# \n# In this project, you'll implement SLAM for robot that moves and senses in a 2 dimensional, grid world!\n# \n# SLAM gives us a way to both localize a robot and build up a map of its environment as a robot moves and senses in real-time. This is an active area of research in the fields of robotics and autonomous systems. Since this localization and map-building relies on the visual sensing of landmarks, this is a computer vision problem. \n# \n# Using what you've learned about robot motion, representations of uncertainty in motion and sensing, and localization techniques, you will be tasked with defining a function, `slam`, which takes in six parameters as input and returns the vector `mu`. \n# > `mu` contains the (x,y) coordinate locations of the robot as it moves, and the positions of landmarks that it senses in the world\n# \n# You can implement helper functions as you see fit, but your function must return `mu`. The vector, `mu`, should have (x, y) coordinates interlaced, for example, if there were 2 poses and 2 landmarks, `mu` will look like the following, where `P` is the robot position and `L` the landmark position:\n# ```\n# mu =  matrix([[Px0],\n#               [Py0],\n#               [Px1],\n#               [Py1],\n#               [Lx0],\n#               [Ly0],\n#               [Lx1],\n#               [Ly1]])\n# ```\n# \n# You can see that `mu` holds the poses first `(x0, y0), (x1, y1), ...,` then the landmark locations at the end of the matrix; we consider a `nx1` matrix to be a vector.\n# \n# ## Generating an environment\n# \n# In a real SLAM problem, you may be given a map that contains information about landmark locations, and in this example, we will make our own data using the `make_data` function, which generates a world grid with landmarks in it and then generates data by placing a robot in that world and moving and sensing over some numer of time steps. The `make_data` function relies on a correct implementation of robot move/sense functions, which, at this point, should be complete and in the `robot_class.py` file. The data is collected as an instantiated robot moves and senses in a world. Your SLAM function will take in this data as input. So, let's first create this data and explore how it represents the movement and sensor measurements that our robot takes.\n# \n# ---\n\n# ## Create the world\n# \n# Use the code below to generate a world of a specified size with randomly generated landmark locations. You can change these parameters and see how your implementation of SLAM responds! \n# \n# `data` holds the sensors measurements and motion of your robot over time. It stores the measurements as `data[i][0]` and the motion as `data[i][1]`.\n# \n# #### Helper functions\n# \n# You will be working with the `robot` class that may look familiar from the first notebook, \n# \n# In fact, in the `helpers.py` file, you can read the details of how data is made with the `make_data` function. It should look very similar to the robot move/sense cycle you've seen in the first notebook.\n\n# In[ ]:\n\n\nimport numpy as np\nfrom helpers import make_data\n\n# your implementation of slam should work with the following inputs\n# feel free to change these input values and see how it responds!\n\n# world parameters\nnum_landmarks      = 5        # number of landmarks\nN                  = 40       # time steps\n# N                  = 2       # time steps\n# world_size         = 100.0    # size of world (square)\nworld_size         = 100.0    # size of world (square)\n\n# robot parameters\n# measurement_range  = 50.0     # range at which we can sense landmarks\nmeasurement_range  = 50.0     # range at which we can sense landmarks\n\nmotion_noise       = 2.0      # noise in robot motion\nmeasurement_noise  = 2.0      # noise in the measurements\n# distance           = 20.0     # distance by which robot (intends to) move each iteratation \ndistance           = 20.0     # distance by which robot (intends to) move each iteratation\n\n\n\n# make_data instantiates a robot, AND generates random landmarks for a given world size and number of landmarks\ndata = make_data(N, num_landmarks, world_size, measurement_range, motion_noise, measurement_noise, distance)\n\n\n# ### A note on `make_data`\n# \n# The function above, `make_data`, takes in so many world and robot motion/sensor parameters because it is responsible for:\n# 1. Instantiating a robot (using the robot class)\n# 2. Creating a grid world with landmarks in it\n# \n# **This function also prints out the true location of landmarks and the *final* robot location, which you should refer back to when you test your implementation of SLAM.**\n# \n# The `data` this returns is an array that holds information about **robot sensor measurements** and **robot motion** `(dx, dy)` that is collected over a number of time steps, `N`. You will have to use *only* these readings about motion and measurements to track a robot over time and find the determine the location of the landmarks using SLAM. We only print out the true landmark locations for comparison, later.\n# \n# \n# In `data` the measurement and motion data can be accessed from the first and second index in the columns of the data array. See the following code for an example, where `i` is the time step:\n# ```\n# measurement = data[i][0]\n# motion = data[i][1]\n# ```\n# \n\n# In[ ]:\n\n\n# print out some stats about the data\ntime_step = 0\n\nprint('Example measurements: \\n', data[time_step][0])\nprint('\\n')\nprint('Example motion: \\n', data[time_step][1])\n\n\n# Try changing the value of `time_step`, you should see that the list of measurements varies based on what in the world the robot sees after it moves. As you know from the first notebook, the robot can only sense so far and with a certain amount of accuracy in the measure of distance between its location and the location of landmarks. The motion of the robot always is a vector with two values: one for x and one for y displacement. This structure will be useful to keep in mind as you traverse this data in your implementation of slam.\n\n# ## Initialize Constraints\n# \n# One of the most challenging tasks here will be to create and modify the constraint matrix and vector: omega and xi. In the second notebook, you saw an example of how omega and xi could hold all the values the define the relationships between robot poses `xi` and landmark positions `Li` in a 1D world, as seen below, where omega is the blue matrix and xi is the pink vector.\n# \n# <img src='images/motion_constraint.png' width=50% height=50% />\n# \n# \n# In *this* project, you are tasked with implementing constraints for a 2D world. We are referring to robot poses as `Px, Py` and landmark positions as `Lx, Ly`, and one way to approach this challenge is to add *both* x and y locations in the constraint matrices.\n# \n# <img src='images/constraints2D.png' width=50% height=50% />\n# \n# You may also choose to create two of each omega and xi (one for x and one for y positions).\n\n# ### TODO: Write a function that initializes omega and xi\n# \n# Complete the function `initialize_constraints` so that it returns `omega` and `xi` constraints for the starting position of the robot. Any values that we do not yet know should be initialized with the value `0`. You may assume that our robot starts out in exactly the middle of the world with 100% confidence (no motion or measurement noise at this point). The inputs `N` time steps, `num_landmarks`, and `world_size` should give you all the information you need to construct intial constraints of the correct size and starting values.\n# \n# *Depending on your approach you may choose to return one omega and one xi that hold all (x,y) positions *or* two of each (one for x values and one for y); choose whichever makes most sense to you!*\n\n# In[ ]:\n\n\ndef initialize_constraints(N, num_landmarks, world_size):\n    ''' This function takes in a number of time steps N, number of landmarks, and a world_size,\n        and returns initialized constraint matrices, omega and xi.'''\n    \n    ## Recommended: Define and store the size (rows/cols) of the constraint matrix in a variable\n    size = 2 * N + 2 * num_landmarks\n\n    ## TODO: Define the constraint matrix, Omega, with two initial \"strength\" values\n    ## for the initial x, y location of our robot\n    omega = np.zeros((size, size))\n    omega[0][0] = 1.0\n    omega[1][1] = 1.0\n    \n    ## TODO: Define the constraint *vector*, xi\n    ## you can assume that the robot starts out in the middle of the world with 100% confidence\n    xi = np.zeros((size, 1))\n    xi[0][0] = world_size/2\n    xi[1][0] = world_size/2\n    \n    return omega, xi\n\n\n# ### Test as you go\n# \n# It's good practice to test out your code, as you go. Since `slam` relies on creating and updating constraint matrices, `omega` and `xi` to account for robot sensor measurements and motion, let's check that they initialize as expected for any given parameters.\n# \n# Below, you'll find some test code that allows you to visualize the results of your function `initialize_constraints`. We are using the [seaborn](https://seaborn.pydata.org/) library for visualization.\n# \n# **Please change the test values of N, landmarks, and world_size and see the results**. Be careful not to use these values as input into your final smal function.\n# \n# This code assumes that you have created one of each constraint: `omega` and `xi`, but you can change and add to this code, accordingly. The constraints should vary in size with the number of time steps and landmarks as these values affect the number of poses a robot will take `(Px0,Py0,...Pxn,Pyn)` and landmark locations `(Lx0,Ly0,...Lxn,Lyn)` whose relationships should be tracked in the constraint matrices. Recall that `omega` holds the weights of each variable and `xi` holds the value of the sum of these variables, as seen in Notebook 2. You'll need the `world_size` to determine the starting pose of the robot in the world and fill in the initial values for `xi`.\n\n# In[ ]:\n\n\n# import data viz resources\nimport matplotlib.pyplot as plt\nfrom pandas import DataFrame\nimport seaborn as sns\n# get_ipython().run_line_magic('matplotlib', 'inline')\n\n\n# In[ ]:\n\n\n# define a small N and world_size (small for ease of visualization)\nN_test = 5\nnum_landmarks_test = 2\nsmall_world = 10\n\n# initialize the constraints\ninitial_omega, initial_xi = initialize_constraints(N_test, num_landmarks_test, small_world)\n\n\n# In[ ]:\n\n\n# define figure size\nplt.rcParams[\"figure.figsize\"] = (10,7)\n\n# display omega\nsns.heatmap(DataFrame(initial_omega), cmap='Blues', annot=True, linewidths=.5)\n\n\n# In[ ]:\n\n\n# define  figure size\nplt.rcParams[\"figure.figsize\"] = (1,7)\n\n# display xi\nsns.heatmap(DataFrame(initial_xi), cmap='Oranges', annot=True, linewidths=.5)\n\n\n# ---\n# ## SLAM inputs \n# \n# In addition to `data`, your slam function will also take in:\n# * N -   The number of time steps that a robot will be moving and sensing\n# * num_landmarks - The number of landmarks in the world\n# * world_size - The size (w/h) of your world\n# * motion_noise - The noise associated with motion; the update confidence for motion should be `1.0/motion_noise`\n# * measurement_noise - The noise associated with measurement/sensing; the update weight for measurement should be `1.0/measurement_noise`\n# \n# #### A note on noise\n# \n# Recall that `omega` holds the relative \"strengths\" or weights for each position variable, and you can update these weights by accessing the correct index in omega `omega[row][col]` and *adding/subtracting* `1.0/noise` where `noise` is measurement or motion noise. `Xi` holds actual position values, and so to update `xi` you'll do a similar addition process only using the actual value of a motion or measurement. So for a vector index `xi[row][0]` you will end up adding/subtracting one measurement or motion divided by their respective `noise`.\n# \n# ### TODO: Implement Graph SLAM\n# \n# Follow the TODO's below to help you complete this slam implementation (these TODO's are in the recommended order), then test out your implementation! \n# \n# #### Updating with motion and measurements\n# \n# With a 2D omega and xi structure as shown above (in earlier cells), you'll have to be mindful about how you update the values in these constraint matrices to account for motion and measurement constraints in the x and y directions. Recall that the solution to these matrices (which holds all values for robot poses `P` and landmark locations `L`) is the vector, `mu`, which can be computed at the end of the construction of omega and xi as the inverse of omega times xi: $\\mu = \\Omega^{-1}\\xi$\n# \n# **You may also choose to return the values of `omega` and `xi` if you want to visualize their final state!**\n\n# In[ ]:\n\n\n## TODO: Complete the code to implement SLAM\n\n## slam takes in 6 arguments and returns mu, \n## mu is the entire path traversed by a robot (all x,y poses) *and* all landmarks locations\ndef slam(data, N, num_landmarks, world_size, motion_noise, measurement_noise):\n    \n    ## TODO: Use your initilization to create constraint matrices, omega and xi\n    omega, xi = initialize_constraints(N, num_landmarks, world_size)\n\n    ## TODO: Iterate through each time step in the data\n    ## get all the motion and measurement data as you iterate\n    for time_step in range(N-1):\n        ## TODO: update the constraint matrix/vector to account for all *measurements*\n        ## this should be a series of additions that take into account the measurement noise\n        measurements = data[time_step][0]\n        for L_mesurement in measurements:\n            L_index, measurement_x, measurement_y = L_mesurement\n\n            omega[2 * time_step][2 * time_step] += 1 / measurement_noise\n            omega[2 * time_step][2 * (N + L_index)] += -1 / measurement_noise\n            omega[2 * (N + L_index)][2 * time_step] += -1 / measurement_noise\n            omega[2 * (N + L_index)][2 * (N + L_index)] += 1 / measurement_noise\n\n            omega[2 * time_step + 1][2 * time_step + 1] += 1 / measurement_noise\n            omega[2 * time_step + 1][2 * (N + L_index) + 1] += -1 / measurement_noise\n            omega[2 * (N + L_index) + 1][2 * time_step + 1] += -1 / measurement_noise\n            omega[2 * (N + L_index) + 1][2 * (N + L_index) + 1] += 1 / measurement_noise\n\n            xi[2 * time_step] += -measurement_x / measurement_noise\n            xi[2 * (N + L_index)] += measurement_x / measurement_noise\n\n            xi[2 * time_step + 1] += -measurement_y / measurement_noise\n            xi[2 * (N + L_index) + 1] += measurement_y / measurement_noise\n\n            ## TODO: update the constraint matrix/vector to account for all *motion* and motion noise\n            dx, dy = data[time_step][1]\n\n            # update omega matrix for x\n            omega[2 * time_step][2 * time_step] += 1 / measurement_noise\n            omega[2 * time_step][2 * (time_step + 1)] += -1 / measurement_noise\n            omega[2 * (time_step + 1)][2 * time_step] += -1 / measurement_noise\n            omega[2 * (time_step + 1)][2 * (time_step + 1)] += 1 / measurement_noise\n\n            # update omega matrix for y\n            omega[2 * time_step + 1][2 * time_step + 1] += 1 / measurement_noise\n            omega[2 * time_step + 1][2 * time_step + 3] += -1 / measurement_noise\n            omega[2 * time_step + 3][2 * time_step + 1] += -1 / measurement_noise\n            omega[2 * time_step + 3][2 * time_step + 3] += 1 / measurement_noise\n\n            # update xi\n            xi[2 * time_step] += -dx / motion_noise\n            xi[2 * (time_step + 1)] += dx / motion_noise\n            xi[2 * time_step + 1] += -dy / motion_noise\n            xi[2 * time_step + 3] += dy / motion_noise\n    ## TODO: After iterating through all the data\n    ## Compute the best estimate of poses and landmark positions\n    ## using the formula, omega_inverse * Xi\n    omega_inv = np.linalg.inv(np.matrix(omega))\n    mu = omega_inv * xi\n\n    return mu\n\n\n# ## Helper functions\n# \n# To check that your implementation of SLAM works for various inputs, we have provided two helper functions that will help display the estimated pose and landmark locations that your function has produced. First, given a result `mu` and number of time steps, `N`, we define a function that extracts the poses and landmarks locations and returns those as their own, separate lists. \n# \n# Then, we define a function that nicely print out these lists; both of these we will call, in the next step.\n# \n\n# In[ ]:\n\n\n# a helper function that creates a list of poses and of landmarks for ease of printing\n# this only works for the suggested constraint architecture of interlaced x,y poses\ndef get_poses_landmarks(mu, N):\n    # create a list of poses\n    poses = []\n    for i in range(N):\n        poses.append((mu[2*i].item(), mu[2*i+1].item()))\n\n    # create a list of landmarks\n    landmarks = []\n    for i in range(num_landmarks):\n        landmarks.append((mu[2*(N+i)].item(), mu[2*(N+i)+1].item()))\n\n    # return completed lists\n    return poses, landmarks\n\n\n# In[ ]:\n\n\ndef print_all(poses, landmarks):\n    print('\\n')\n    print('Estimated Poses:')\n    for i in range(len(poses)):\n        print('['+', '.join('%.3f'%p for p in poses[i])+']')\n    print('\\n')\n    print('Estimated Landmarks:')\n    for i in range(len(landmarks)):\n        print('['+', '.join('%.3f'%l for l in landmarks[i])+']')\n\n\n# ## Run SLAM\n# \n# Once you've completed your implementation of `slam`, see what `mu` it returns for different world sizes and different landmarks!\n# \n# ### What to Expect\n# \n# The `data` that is generated is random, but you did specify the number, `N`, or time steps that the robot was expected to move and the `num_landmarks` in the world (which your implementation of `slam` should see and estimate a position for. Your robot should also start with an estimated pose in the very center of your square world, whose size is defined by `world_size`.\n# \n# With these values in mind, you should expect to see a result that displays two lists:\n# 1. **Estimated poses**, a list of (x, y) pairs that is exactly `N` in length since this is how many motions your robot has taken. The very first pose should be the center of your world, i.e. `[50.000, 50.000]` for a world that is 100.0 in square size.\n# 2. **Estimated landmarks**, a list of landmark positions (x, y) that is exactly `num_landmarks` in length. \n# \n# #### Landmark Locations\n# \n# If you refer back to the printout of *exact* landmark locations when this data was created, you should see values that are very similar to those coordinates, but not quite (since `slam` must account for noise in motion and measurement).\n\n# In[ ]:\n\n\n# call your implementation of slam, passing in the necessary parameters\nmu = slam(data, N, num_landmarks, world_size, motion_noise, measurement_noise)\n\n# print out the resulting landmarks and poses\nif(mu is not None):\n    # get the lists of poses and landmarks\n    # and print them out\n    poses, landmarks = get_poses_landmarks(mu, N)\n    print_all(poses, landmarks)\n\n\n# ## Visualize the constructed world\n# \n# Finally, using the `display_world` code from the `helpers.py` file (which was also used in the first notebook), we can actually visualize what you have coded with `slam`: the final position of the robot and the positon of landmarks, created from only motion and measurement data!\n# \n# **Note that these should be very similar to the printed *true* landmark locations and final pose from our call to `make_data` early in this notebook.**\n\n# In[ ]:\n\n\n# import the helper function\nfrom helpers import display_world\n\n# Display the final world!\n\n# define figure size\nplt.rcParams[\"figure.figsize\"] = (20,20)\n\n# check if poses has been created\nif 'poses' in locals():\n    # print out the last pose\n    print('Last pose: ', poses[-1])\n    # display the last position of the robot *and* the landmark positions\n    display_world(int(world_size), poses[-1], landmarks)\n\n\n# ### Question: How far away is your final pose (as estimated by `slam`) compared to the *true* final pose? Why do you think these poses are different?\n# \n# You can find the true value of the final pose in one of the first cells where `make_data` was called. You may also want to look at the true landmark locations and compare them to those that were estimated by `slam`. Ask yourself: what do you think would happen if we moved and sensed more (increased N)? Or if we had lower/higher noise parameters.\n\n# **Answer**: (Write your answer here.)\n\n# ## Testing\n# \n# To confirm that your slam code works before submitting your project, it is suggested that you run it on some test data and cases. A few such cases have been provided for you, in the cells below. When you are ready, uncomment the test cases in the next cells (there are two test cases, total); your output should be **close-to or exactly** identical to the given results. If there are minor discrepancies it could be a matter of floating point accuracy or in the calculation of the inverse matrix.\n# \n# ### Submit your project\n# \n# If you pass these tests, it is a good indication that your project will pass all the specifications in the project rubric. Follow the submission instructions to officially submit!\n\n# In[ ]:\n\n\n# Here is the data and estimated outputs for test case 1\n\ntest_data1 = [[[[1, 19.457599255548065, 23.8387362100849], [2, -13.195807561967236, 11.708840328458608], [3, -30.0954905279171, 15.387879242505843]], [-12.2607279422326, -15.801093326936487]], [[[2, -0.4659930049620491, 28.088559771215664], [4, -17.866382374890936, -16.384904503932]], [-12.2607279422326, -15.801093326936487]], [[[4, -6.202512900833806, -1.823403210274639]], [-12.2607279422326, -15.801093326936487]], [[[4, 7.412136480918645, 15.388585962142429]], [14.008259661173426, 14.274756084260822]], [[[4, -7.526138813444998, -0.4563942429717849]], [14.008259661173426, 14.274756084260822]], [[[2, -6.299793150150058, 29.047830407717623], [4, -21.93551130411791, -13.21956810989039]], [14.008259661173426, 14.274756084260822]], [[[1, 15.796300959032276, 30.65769689694247], [2, -18.64370821983482, 17.380022987031367]], [14.008259661173426, 14.274756084260822]], [[[1, 0.40311325410337906, 14.169429532679855], [2, -35.069349468466235, 2.4945558982439957]], [14.008259661173426, 14.274756084260822]], [[[1, -16.71340983241936, -2.777000269543834]], [-11.006096015782283, 16.699276945166858]], [[[1, -3.611096830835776, -17.954019226763958]], [-19.693482634035977, 3.488085684573048]], [[[1, 18.398273354362416, -22.705102332550947]], [-19.693482634035977, 3.488085684573048]], [[[2, 2.789312482883833, -39.73720193121324]], [12.849049222879723, -15.326510824972983]], [[[1, 21.26897046581808, -10.121029799040915], [2, -11.917698965880655, -23.17711662602097], [3, -31.81167947898398, -16.7985673023331]], [12.849049222879723, -15.326510824972983]], [[[1, 10.48157743234859, 5.692957082575485], [2, -22.31488473554935, -5.389184118551409], [3, -40.81803984305378, -2.4703329790238118]], [12.849049222879723, -15.326510824972983]], [[[0, 10.591050242096598, -39.2051798967113], [1, -3.5675572049297553, 22.849456408289125], [2, -38.39251065320351, 7.288990306029511]], [12.849049222879723, -15.326510824972983]], [[[0, -3.6225556479370766, -25.58006865235512]], [-7.8874682868419965, -18.379005523261092]], [[[0, 1.9784503557879374, -6.5025974151499]], [-7.8874682868419965, -18.379005523261092]], [[[0, 10.050665232782423, 11.026385307998742]], [-17.82919359778298, 9.062000642947142]], [[[0, 26.526838150174818, -0.22563393232425621], [4, -33.70303936886652, 2.880339841013677]], [-17.82919359778298, 9.062000642947142]]]\n\n##  Test Case 1\n##\n# Estimated Pose(s):\n#     [50.000, 50.000]\n#     [37.858, 33.921]\n#     [25.905, 18.268]\n#     [13.524, 2.224]\n#     [27.912, 16.886]\n#     [42.250, 30.994]\n#     [55.992, 44.886]\n#     [70.749, 59.867]\n#     [85.371, 75.230]\n#     [73.831, 92.354]\n#     [53.406, 96.465]\n#     [34.370, 100.134]\n#     [48.346, 83.952]\n#     [60.494, 68.338]\n#     [73.648, 53.082]\n#     [86.733, 38.197]\n#     [79.983, 20.324]\n#     [72.515, 2.837]\n#     [54.993, 13.221]\n#     [37.164, 22.283]\n\n\n# Estimated Landmarks:\n#     [82.679, 13.435]\n#     [70.417, 74.203]\n#     [36.688, 61.431]\n#     [18.705, 66.136]\n#     [20.437, 16.983]\n\n\n### Uncomment the following three lines for test case 1 and compare the output to the values above ###\n\n# mu_1 = slam(test_data1, 20, 5, 100.0, 2.0, 2.0)\n# poses, landmarks = get_poses_landmarks(mu_1, 20)\n# print_all(poses, landmarks)\n\n\n# In[ ]:\n\n\n# Here is the data and estimated outputs for test case 2\n\ntest_data2 = [[[[0, 26.543274387283322, -6.262538160312672], [3, 9.937396825799755, -9.128540360867689]], [18.92765331253674, -6.460955043986683]], [[[0, 7.706544739722961, -3.758467215445748], [1, 17.03954411948937, 31.705489938553438], [3, -11.61731288777497, -6.64964096716416]], [18.92765331253674, -6.460955043986683]], [[[0, -12.35130507136378, 2.585119104239249], [1, -2.563534536165313, 38.22159657838369], [3, -26.961236804740935, -0.4802312626141525]], [-11.167066095509824, 16.592065417497455]], [[[0, 1.4138633151721272, -13.912454837810632], [1, 8.087721200818589, 20.51845934354381], [3, -17.091723454402302, -16.521500551709707], [4, -7.414211721400232, 38.09191602674439]], [-11.167066095509824, 16.592065417497455]], [[[0, 12.886743222179561, -28.703968411636318], [1, 21.660953298391387, 3.4912891084614914], [3, -6.401401414569506, -32.321583037341625], [4, 5.034079343639034, 23.102207946092893]], [-11.167066095509824, 16.592065417497455]], [[[1, 31.126317672358578, -10.036784369535214], [2, -38.70878528420893, 7.4987265861424595], [4, 17.977218575473767, 6.150889254289742]], [-6.595520680493778, -18.88118393939265]], [[[1, 41.82460922922086, 7.847527392202475], [3, 15.711709540417502, -30.34633659912818]], [-6.595520680493778, -18.88118393939265]], [[[0, 40.18454208294434, -6.710999804403755], [3, 23.019508919299156, -10.12110867290604]], [-6.595520680493778, -18.88118393939265]], [[[3, 27.18579315312821, 8.067219022708391]], [-6.595520680493778, -18.88118393939265]], [[], [11.492663265706092, 16.36822198838621]], [[[3, 24.57154567653098, 13.461499960708197]], [11.492663265706092, 16.36822198838621]], [[[0, 31.61945290413707, 0.4272295085799329], [3, 16.97392299158991, -5.274596836133088]], [11.492663265706092, 16.36822198838621]], [[[0, 22.407381798735177, -18.03500068379259], [1, 29.642444125196995, 17.3794951934614], [3, 4.7969752441371645, -21.07505361639969], [4, 14.726069092569372, 32.75999422300078]], [11.492663265706092, 16.36822198838621]], [[[0, 10.705527984670137, -34.589764174299596], [1, 18.58772336795603, -0.20109708164787765], [3, -4.839806195049413, -39.92208742305105], [4, 4.18824810165454, 14.146847823548889]], [11.492663265706092, 16.36822198838621]], [[[1, 5.878492140223764, -19.955352450942357], [4, -7.059505455306587, -0.9740849280550585]], [19.628527845173146, 3.83678180657467]], [[[1, -11.150789592446378, -22.736641053247872], [4, -28.832815721158255, -3.9462962046291388]], [-19.841703647091965, 2.5113335861604362]], [[[1, 8.64427397916182, -20.286336970889053], [4, -5.036917727942285, -6.311739993868336]], [-5.946642674882207, -19.09548221169787]], [[[0, 7.151866679283043, -39.56103232616369], [1, 16.01535401373368, -3.780995345194027], [4, -3.04801331832137, 13.697362774960865]], [-5.946642674882207, -19.09548221169787]], [[[0, 12.872879480504395, -19.707592098123207], [1, 22.236710716903136, 16.331770792606406], [3, -4.841206109583004, -21.24604435851242], [4, 4.27111163223552, 32.25309748614184]], [-5.946642674882207, -19.09548221169787]]] \n\n\n##  Test Case 2\n##\n# Estimated Pose(s):\n#     [50.000, 50.000]\n#     [69.035, 45.061]\n#     [87.655, 38.971]\n#     [76.084, 55.541]\n#     [64.283, 71.684]\n#     [52.396, 87.887]\n#     [44.674, 68.948]\n#     [37.532, 49.680]\n#     [31.392, 30.893]\n#     [24.796, 12.012]\n#     [33.641, 26.440]\n#     [43.858, 43.560]\n#     [54.735, 60.659]\n#     [65.884, 77.791]\n#     [77.413, 94.554]\n#     [96.740, 98.020]\n#     [76.149, 99.586]\n#     [70.211, 80.580]\n#     [64.130, 61.270]\n#     [58.183, 42.175]\n\n\n# Estimated Landmarks:\n#     [76.777, 42.415]\n#     [85.109, 76.850]\n#     [13.687, 95.386]\n#     [59.488, 39.149]\n#     [69.283, 93.654]\n\n\n### Uncomment the following three lines for test case 2 and compare to the values above ###\n\nmu_2 = slam(test_data2, 13, 5, 100.0, 3.0, 3.0)\nposes, landmarks = get_poses_landmarks(mu_2, 13)\nprint_all(poses, landmarks)\n\n", "meta": {"hexsha": "389a192e1f8691fc1cd9553049cd5c051fe5e7c2", "size": 28437, "ext": "py", "lang": "Python", "max_stars_repo_path": "3. Landmark Detection and Tracking.py", "max_stars_repo_name": "laozhuang727/P3_Implement_SLAM", "max_stars_repo_head_hexsha": "dd474e7c1c870648b2e2a89ade7893c463330286", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "3. Landmark Detection and Tracking.py", "max_issues_repo_name": "laozhuang727/P3_Implement_SLAM", "max_issues_repo_head_hexsha": "dd474e7c1c870648b2e2a89ade7893c463330286", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "3. Landmark Detection and Tracking.py", "max_forks_repo_name": "laozhuang727/P3_Implement_SLAM", "max_forks_repo_head_hexsha": "dd474e7c1c870648b2e2a89ade7893c463330286", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 56.7604790419, "max_line_length": 3030, "alphanum_fraction": 0.7019376165, "include": true, "reason": "import numpy", "num_tokens": 8422, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48828339529583464, "lm_q2_score": 0.11436853674701283, "lm_q1q2_score": 0.055844257437847857}}
{"text": "'''\r\nUtility functions\r\n\r\n@author Jonathan Karr, karr@mssm.edu\r\n@date 3/22/2016\r\n'''\r\n\r\nimport numpy as np\r\n\r\nN_AVOGADRO = 6.022e23\r\n# Avogadro constant\r\n\r\ndef nanminimum(x, y):\r\n    return np.where(np.logical_or(np.isnan(y), np.logical_and(x <= y, np.logical_not(np.isnan(x)))), x, y)\r\n\r\ndef nanmaximum(x, y):\r\n    return np.where(np.logical_or(np.isnan(y), np.logical_and(x >= y, np.logical_not(np.isnan(x)))), x, y)\r\n\r\n", "meta": {"hexsha": "558a1ae22123e4812a3260c1a8be869c77d0b23b", "size": 422, "ext": "py", "lang": "Python", "max_stars_repo_path": "intro_to_wc_modeling/cell_modeling/simulation/multi_algorithm/util.py", "max_stars_repo_name": "KarrLab/python_package_tutorial", "max_stars_repo_head_hexsha": "dd20e0d3056138904e7e7fbbf6bb884d64dbf8f6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2018-01-06T11:33:01.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T15:18:40.000Z", "max_issues_repo_path": "intro_to_wc_modeling/cell_modeling/simulation/multi_algorithm/util.py", "max_issues_repo_name": "KarrLab/python_package_tutorial", "max_issues_repo_head_hexsha": "dd20e0d3056138904e7e7fbbf6bb884d64dbf8f6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-01-30T23:21:12.000Z", "max_issues_repo_issues_event_max_datetime": "2018-03-23T20:22:06.000Z", "max_forks_repo_path": "intro_to_wc_modeling/cell_modeling/simulation/multi_algorithm/util.py", "max_forks_repo_name": "KarrLab/python_package_tutorial", "max_forks_repo_head_hexsha": "dd20e0d3056138904e7e7fbbf6bb884d64dbf8f6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2018-01-08T21:40:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-04T14:48:02.000Z", "avg_line_length": 22.2105263158, "max_line_length": 107, "alphanum_fraction": 0.654028436, "include": true, "reason": "import numpy", "num_tokens": 125, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4416730056646256, "lm_q2_score": 0.12592277139559052, "lm_q1q2_score": 0.05561668892391}}
{"text": "\"\"\"\r\nCollection of algorithms (geared towards abstract math and numerical problems)\r\n\r\nPicked up from MA and now continued from Cooling Singapore. Oct 2019\r\n\"\"\"\r\n\r\n# This control flag is used to skip sections if their prerequisite modules are not available, so that DK_Numerical\r\n# can be imported more flexibly with regards to the environment.\r\n\r\n_control = {section: True for section in ('NetworkX', 'Pandas', 'numpy')}\r\n\r\ntry:\r\n\timport networkx as nx\r\nexcept ModuleNotFoundError:\r\n\t_control['NetworkX'] = False\r\n\r\ntry:\r\n\timport pandas as pd\r\nexcept ModuleNotFoundError:\r\n\t_control['Pandas'] = False\r\n\r\ntry:\r\n\timport numpy as np\r\nexcept ModuleNotFoundError:\r\n\t_control['numpy'] = False\r\n\r\nimport warnings\r\n\r\n\r\n# -------------------------------------------- NetworkX ------------------------------------------------ #\r\nif _control['NetworkX']:\r\n\tdef get_treeroot(tree, guess=None):\r\n\t\t\"\"\"\r\n\t\tFinds the root node of a NetworkX DiGraph tree.\r\n\r\n\t\tArgs:\r\n\t\t\ttree: NetworkX DiGraph tree\r\n\t\t\tguess: Best bet for which node is the root. The closer this node is to the root, the faster the search.\r\n\r\n\t\tReturns:\r\n\t\t\tRoot node of tree.\r\n\t\t\"\"\"\r\n\r\n\t\t# Step 1: Param checks\r\n\t\tif not isinstance(tree, nx.DiGraph):\r\n\t\t\traise TypeError(\"Must pass a NetworkX Digraph to parameter 'tree.'\")\r\n\r\n\t\tif not nx.is_tree(tree):\r\n\t\t\traise ValueError(\"Passed graph is not a tree.\")\r\n\r\n\t\tif guess is None:\r\n\t\t\tguess = list(tree.nodes)[0]\r\n\t\telse:\r\n\t\t\tif guess not in tree:\r\n\t\t\t\twarnings.warn(\"The guessed root node is not in the tree.\")\r\n\t\t\t\tguess = list(tree.nodes)[0]\r\n\r\n\r\n\t\t# Step 2: Follow predecessors until you find the root\r\n\t\troot = guess\r\n\t\tcounter = 1\r\n\t\tn_nodes = len(tree)\r\n\r\n\t\t# This is a redundant loop, but Iterator Protocol + NetworkX guarantees that this is unnecessary.\r\n\t\twhile counter <= n_nodes:\r\n\t\t\ttry:\r\n\t\t\t\troot = next(tree.predecessors(root))\r\n\t\t\t\tcounter += 1\r\n\t\t\texcept StopIteration: # raised for the root node (no predecessors)\r\n\t\t\t\tbreak\r\n\r\n\r\n\t\treturn root\r\n\r\n\r\n\tdef compare_trees(T1, T2):\r\n\t\t\"\"\"\r\n\t\tReturns true if the trees are IDENTICAL (isomorphism is necessary but insufficient), and False otherwise.\r\n\r\n\t\tTwo trees are identical iff:\r\n\t\t\t1) same set of nodes\r\n\t\t\t2) same set of branches\r\n\t\t\t3) same branch params\r\n\t\t\t(for now, assumed no node params)\r\n\r\n\t\tDEVELOPER'S CORNER:\r\n\t\t\tI learned that dictionaries can be tested for equality via ==. There's also talk on StackOverflow about this\r\n\t\t\tequality test holding for nested dicts (and other nesting combinations with other data structures).\r\n\r\n\t\t\"\"\"\r\n\t\tif not isinstance(T1, nx.DiGraph) or not isinstance(T2, nx.DiGraph):\r\n\t\t\traise TypeError(\"This function only accepts NetworkX DiGraphs.\")\r\n\r\n\t\tif not nx.faster_could_be_isomorphic(T1, T2):\r\n\t\t\treturn False\r\n\r\n\t\t# Check 1: Compare nodes\r\n\t\tif set(T1) != set(T2):\r\n\t\t\treturn False\r\n\r\n\t\t# Check 2: Compare branches\r\n\t\tbr1 = set(br for br in T1.edges())\r\n\t\tbr2 = set(br for br in T2.edges())\r\n\r\n\t\tif br1 != br2:\r\n\t\t\treturn False\r\n\r\n\t\t# Check 3: Compare branch parameters (final test)\r\n\t\treturn all([T1.edges[up, down] == T2.edges[up, down] for up, down in br1])\r\n\r\n\r\n# -------------------------------------------- Pandas ------------------------------------------------ #\r\nif _control['Pandas']:\r\n\tdef empty_df_with_dtypes(col_dtype: dict):\r\n\t\t\"\"\"Initializes a pandas DataFrame with NO ROWS, but with col labels AND datatypes. The DataFrame constructor only\r\n\t\tlets you specify one datatype for all the columns, so this function fills that gap.\r\n\r\n\t\tArgs:\r\n\t\t\tcol_dtype: as dictionary of 'column label':'numpy dtype' pairs\r\n\r\n\t\tNote: This solution is adapted from the one proposed in stackoverflow,\r\n\t\thttps://stackoverflow.com/questions/36462257/create-empty-dataframe-in-pandas-specifying-column-types/48374031#48374031\r\n\r\n\r\n\t\tReturns:\r\n\t\t\tEmpty DataFrame, with columns + dtype specified.\r\n\r\n\t\t\"\"\"\r\n\t\tif not isinstance(col_dtype, dict):\r\n\t\t\traise TypeError(\"Pls. pass a dictionary of 'column label':'numpy dtype' pairs.\")\r\n\r\n\t\tif len(col_dtype) == 0:\r\n\t\t\traise RuntimeError(\"Requested table has no columns.\")\r\n\r\n\t\tdf = pd.DataFrame()\r\n\r\n\t\tfor c, d in col_dtype.items():\r\n\t\t\tdf[c] = pd.Series(dtype=d)\r\n\r\n\t\treturn df\r\n\r\n\r\n\tdef is_xymonotonic(x, y, slope='pos', getdf=False, as_assertion=False):\r\n\t\t\"\"\"Checks if the given relationship <x, y> is monotonic in the specified direction ('pos' or 'neg' slope). A\r\n\t\tmonotonic line is one whose slope is consistently either non-neg or non-pos. Pass vectors (iterables) to x\r\n\t\tand y. x has to be strictly increasing, whereas y can have repeating subsequent points (flat slope).\r\n\r\n\t\tReturns a tuple (bool, list):\r\n\t\t\tBool is True if monotonic in the specified direction.\r\n\r\n\t\t\tList is empty if bool is True. Otherwise, contains the indices (0-indexed range is assigned to the data)\r\n\r\n\t\t\tif getdf is True, then a third item is returned as a pandas DataFrame of vectors x and y, with column\r\n\t\t\tnames as 'x' and 'y'.\r\n\r\n\t\tTo assert monotonicity:\r\n\t\t\tassert is_xymonotonic(x, y, slope='pos')[0]\r\n\r\n\t\tTo assert monotinicity internally\r\n\t\t\tis_xymonotonic(x, y, slope='pos', as_assertion=True)\r\n\r\n\t\t\"\"\"\r\n\r\n\t\t# ----------------------------------------------------------------------- Checks\r\n\t\tlength = len(x)\r\n\t\tif length != len(y):\r\n\t\t\traise ValueError(\"Vectors x and y have to be of the same length.\")\r\n\t\tif length < 3:\r\n\t\t\traise ValueError(\"Vectors x and y must have at least 3 points.\")\r\n\r\n\r\n\r\n\t\t# ----------------------------------------------------------------------- Convert to Series\r\n\t\t# x2, y2 is the same data but shifted one index forward wrt x1 and y1  -- old implementation\r\n\t\tx = pd.Series(data=(pt for pt in x))\r\n\t\t# x2 = pd.Series(data=x1.values, index=pd.RangeIndex(-1, length-1))\r\n\r\n\t\ty = pd.Series(data=(pt for pt in y))\r\n\t\t# y2 = pd.Series(data=y1.values, index=pd.RangeIndex(-1, length-1))\r\n\r\n\t\t# ----------------------------------------------------------------------- Calc dx and dy\r\n\t\t# dx = x2-x1\r\n\t\tdx = x.diff()\r\n\t\tdx = dx.loc[dx.notna()]\r\n\r\n\t\t# dy = y2-y1\r\n\t\tdy = y.diff()\r\n\t\tdy = dy.loc[dy.notna()]\r\n\r\n\t\t# Check that all dx > 0\r\n\t\tLf_invalid_dx = dx <= 0\r\n\t\tif Lf_invalid_dx.any():\r\n\t\t\t# Collect indeces of points (+next point) where dx <= 0\r\n\t\t\tinvalid_idx = Lf_invalid_dx.loc[Lf_invalid_dx].index\r\n\t\t\tinvalid_idx_withadj = pd.Index(set(invalid_idx).union(invalid_idx+1))\r\n\r\n\t\t\tprint(\"x vector can only be increasing. Pls. view the slice: \\n{}\".format(x.loc[invalid_idx_withadj]))\r\n\t\t\traise ValueError(invalid_idx_withadj)\r\n\r\n\t\t# ----------------------------------------------------------------------- Check if monotonic\r\n\t\tsign = {'pos': 1}.get(slope, -1)\r\n\t\t# sign * dy must be >= 0 for all entries to fulfill the specified monotonicity\r\n\t\tLf_failed = sign * dy < 0\r\n\r\n\t\treturned_value = (not any(Lf_failed), list(Lf_failed.loc[Lf_failed].index))\r\n\r\n\t\tif as_assertion:\r\n\t\t\tassert returned_value[0], returned_value[1]\r\n\r\n\t\tif getdf:\r\n\t\t\treturned_value += (pd.DataFrame({'x': x, 'y': y}), )\r\n\t\treturn returned_value\r\n\r\n\r\n\tdef sortxy(x, y, ascending=True):\r\n\t\t\"\"\"Given vectors x and y (as iterables that are ordered and 1:1), sortxy() sorts these vectors in ascending\r\n\t\tor descending order (via param 'ascending'), and returns them in a DataFrame with a range index. No check is\r\n\t\tdone if x has repeating values.\"\"\"\r\n\t\t# todo consider keeping the original index, if ever necessary\r\n\r\n\t\t# ----------------------------------------------------------------------- Checks\r\n\t\tlength = len(x)\r\n\t\tif length != len(y):\r\n\t\t\traise ValueError(\"Vectors x and y have to be of the same length.\")\r\n\r\n\t\t# ----------------------------------------------------------------------- Convert to Series\r\n\t\t# Range index here stores the mapping x --> y\r\n\t\tSerx = pd.Series(data=(pt for pt in x))\r\n\t\tSery = pd.Series(data=(pt for pt in y))\r\n\r\n\t\t# ----------------------------------------------------------------------- Sort and return df\r\n\t\tSerx_sorted = Serx.sort_values(ascending=ascending)\r\n\r\n\t\treturn pd.DataFrame({\r\n\t\t\t'x': Serx_sorted.values,\r\n\t\t\t'y': Sery.loc[Serx_sorted.index].values,\r\n\t\t})\r\n\r\n\r\n# -------------------------------------------- numpy ------------------------------------------------ #\r\nif _control['numpy']:\r\n\tdef clip(f, lb=None, ub=None):\r\n\t\t\"\"\"Return a clipped version of callable f(). This is the counterpart of numpy.clip(),\r\n\t\twhich only works on explicit arrays, for callables.\r\n\r\n\t\tlb and ub follow the same requirements as in their counterparts in numpy.clip().\r\n\t\t\"\"\"\r\n\t\tif ub < lb:\r\n\t\t\traise ValueError(\"ub < lb\")\r\n\t\treturn lambda x: np.clip(f(x), lb, ub)\r\n\r\n\r\n\tdef apply_f_every_n(arr, n, func=np.sum, res_dtype='f8'):\r\n\t\t\"\"\"Apply function func() to every n elements of array. The length of array arr must be a multiple of n,\r\n\t\tbut this is not checked (last operation would fall short of elements w/o raising an exception).\r\n\r\n\r\n\t\tsample usage:\r\n\t\t\t# Downscale the resolution by half, while getting the mean of the data points\r\n\t\t\tapply_f_every_n(ser.values, 2, np.mean)\r\n\r\n\t\t\t# You can use this via DataFrame.apply(). Here, we are changing a 24-h, half-hourly dataset into an hourly one.\r\n\t\t\tdf_24h_hh.apply(apply_f_every_n, axis=0, args=(2, np.mean))\r\n\t\t\"\"\"\r\n\t\tstart_idxs = np.arange(0, arr.shape[0], n)\r\n\r\n\t\treturn np.fromiter((func(arr[idx:idx + n]) for idx in start_idxs), dtype=res_dtype)\r\n\r\n\r\n# -------------------------------------------- Uncategorized Python ------------------------------------------------ #\r\ndef get_dictvals(mydict):\r\n\t\"\"\"This function recursively gets all non-dict items in a hierarchical dict data structure. The order of the items have no intended meaning.\r\n\r\n\te.g.\r\n\t\tmyheir = {\r\n\t\t\t0: '0.0',\r\n\t\t\t1: '0.1',\r\n\t\t\t2: {0: '1.0', 1: '1.1'},\r\n\t\t\t3: {0: '1.2', 1: {0: '2.0', 1: '2.1', 2: {0: '3.0'}, 3:'2.2'}},\r\n\t\t\t4: {0: '1.3', 1: '1.4'},\r\n\t\t\t5: '0.2',\r\n\t\t}\r\n\r\n\tget_dictvals(myheir)\r\n\t>> ['0.0', '0.1', '1.0', '1.1', '1.2', '2.0', '2.1', '3.0', '2.2', '1.3', '1.4', '0.2']\r\n\r\n\t\"\"\"\r\n\tvalues = []\r\n\r\n\tfor val in mydict.values():\r\n\t\tif isinstance(val, dict):\r\n\t\t\tvalues.extend(get_dictvals(val))\r\n\t\telse:\r\n\t\t\tvalues.append(val)\r\n\treturn values\r\n\r\n\r\n\r\n# -------------------------------------------- Tuple Arithmetic ------------------------------------------------ #\r\n# FOR DEVELOPMENT:\r\n#    1) Sequences of tuples should be contained in sets.\r\n#\r\n\r\ndef totuple(item):\r\n\tif isinstance(item, (str, int)):\r\n\t\treturn tuple([item])\r\n\telse:\r\n\t\treturn tuple(item)\r\n\r\n\r\ndef tupsum(*addends, strAsOne=True):\r\n\t\"\"\"\r\n\tPerforms a tuple addition on an indefinite number of tuples. Arguments must be tuple-coercibles (they must be\r\n\titerables or iterators), or scalars (i.e. tuple([arg]) succeeds).\r\n\r\n\tReturns:\r\n\t\tA tuple of the tuple sum of the addends.\r\n\r\n\tDEVELOPER'S CORNER:\r\n\t\tTuples support concatenation, ie (1) + (0) = (1,0), which is really what tupple addition is in the context of\r\n\t\tthe Cartesian product.\r\n\r\n\t\ttuple() returns an empty tuple, which guarantees that 'sum' will support concatenation.\r\n\r\n\t\tIf an addend is not a tuple, tuple() coerces it (same elements).\r\n\t\tIf an addend cannot be coerced directly, then it is expected to be a scalar (usu. numeric or string),\r\n\t\tand thus containing it via tuple([a]) should work.\r\n\t\"\"\"\r\n\tsum = tuple()\r\n\r\n\tfor a in addends:\r\n\t\tif type(a) is str and strAsOne:\r\n\t\t\ta = tuple([a])\r\n\t\ttry:\r\n\t\t\tsum = sum + tuple(a)\r\n\t\texcept TypeError:\r\n\t\t\tsum = sum + tuple([a])\r\n\r\n\treturn sum\r\n\r\n\r\ndef tupadd(a, b):\r\n\t\"\"\"\r\n\tPerforms a tuple addition of a and b.\r\n\r\n\tArgs: a and b can either be 1) scalars (i.e. single coordinate) or 2) elementary tuples\r\n\r\n\tAny argument that is a tuple (assumed elementary; i.e. all its elements are scalars) is unpacked as can be seen\r\n\tbelow.\r\n\r\n\tAs far as the author knows, this function cannot be extended to an arbitrary number of addends (by taking a\r\n\tvar-positional parameter), because the statement a = *a is not allowed. To sum an indefinite number of addends,\r\n\tone way to achieve this is by looping every addend pair, much like how tuppi works.\r\n\r\n\tReturns:\r\n\t\tThe tuple sum of a and b (GUARANTEED elementary tuple if a and b are elementary tuples or scalars).\r\n\t\"\"\"\r\n\tif type(a) == tuple and type(b) == tuple:\r\n\t\treturn tuple([*a, *b])\r\n\telif type(a) == tuple:\r\n\t\treturn tuple([*a, b])\r\n\telif type(b) == tuple:\r\n\t\treturn tuple([a, *b])\r\n\telse:\r\n\t\treturn tuple([a, b])\r\n\r\n\r\ndef tuppi(*factors):\r\n\t\"\"\"\r\n\tPerforms a Cartesian product of all of its factors.\r\n\r\n\tArgs:\r\n\t\t*factors: An iterable of tuple-coercibles. If you want a 1-dim tuple, pass it as (a,) and not a.\r\n\r\n\tReturns:\r\n\t\tThe Cartesian product as a tuple.\r\n\r\n\tDEVELOPER'S CORNER:\r\n\t\tIf the factors are all elementary tuples or scalars, the product is GUARANTEED to be an elementary tuple.\r\n\t\tEven if after every iteration of the for factor .. loop, product is contained in a tuple, this container is\r\n\t\t\"opened up\" by the same generator expression come next iteration. The container is opened and new (and more)\r\n\t\telements are repacked in it.\r\n\r\n\t\"\"\"\r\n\t# Require that factors is an iterable of tuple-coercibles\r\n\ttup_factors = [tuple(i) for i in factors]\r\n\r\n\t# init product to 1st factor * 1\r\n\tproduct = tup_factors[0]\r\n\r\n\tfor factor in tup_factors[1:]:\r\n\t\tproduct = tuple(tupadd(a, b) for a in product for b in factor)\r\n\t\t#         RHS is precisely the def'n of the Cartesian Product, product x factor\r\n\r\n\treturn product\r\n\r\n\r\ndef tupsumproduct(tree):\r\n\t\"\"\"\r\n\tThis function performs a sum of products.\r\n\r\n\tArgs:\r\n\t\ttree: dictionary of {iterable of parents : iterable of children}\r\n\r\n\tReturns:\r\n\t\tThe tuple sum of products as a tuple, i.e., sum( keys x values )\r\n\r\n\r\n\tDEVELOPER'S CORNER:\r\n\t\tThis generator expression will iterate through all its for clauses, before stringing them together.\r\n\t\tAs tupadd() is guaranteed to return elementary tuples (so long as arguments are elementary tuples or scalars),\r\n\t\tthe generator produces a sequence of elementary tuples, which are then finally packed in the tuple() constructor.\r\n\t\tI could have used a list(), but using tuple() is safe as tuple(any_tuple) == any_tuple. The external\r\n\t\tcontainer type can be any sequence. I just chose tuples for both this function and tuppi so that the\r\n\t\tcontainers are immutable, if you want to use them directlty.\r\n\r\n\t\"\"\"\r\n\tprm_tuples = {totuple(key): totuple(val) for key, val in tree.items()}\r\n\treturn tuple(tupadd(parent, child) for key, val in prm_tuples.items() for parent in key for child in val)\r\n\t#                                  SUM (of heterogenous key:val mappings)     PRODUCTS (key x val)\r\n\r\n\r\n\r\n\r\n", "meta": {"hexsha": "25dcc1c6c5c66585dff648e8928343d18e5afeab", "size": 14343, "ext": "py", "lang": "Python", "max_stars_repo_path": "DK_Numerical.py", "max_stars_repo_name": "cooling-singapore/genDispatch", "max_stars_repo_head_hexsha": "1b9743928326e55accda162413f0ce1d9ae54093", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "DK_Numerical.py", "max_issues_repo_name": "cooling-singapore/genDispatch", "max_issues_repo_head_hexsha": "1b9743928326e55accda162413f0ce1d9ae54093", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "DK_Numerical.py", "max_forks_repo_name": "cooling-singapore/genDispatch", "max_forks_repo_head_hexsha": "1b9743928326e55accda162413f0ce1d9ae54093", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-19T06:41:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-19T06:41:21.000Z", "avg_line_length": 33.7482352941, "max_line_length": 142, "alphanum_fraction": 0.6293662414, "include": true, "reason": "import numpy,import networkx", "num_tokens": 3647, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4649015713733885, "lm_q2_score": 0.11920291576401233, "lm_q1q2_score": 0.055417622850978995}}
{"text": "\"\"\"This module provides classes that allow Numpy-type access\r\nto VTK datasets and arrays. This is best described with some examples.\r\n\r\nTo normalize a VTK array:\r\n\r\nimport vtk\r\nimport vtk.numpy_interface.dataset_adapter as dsa\r\nimport vtk.numpy_interface.algorithms as algs\r\n\r\nrt = vtk.vtkRTAnalyticSource()\r\nrt.Update()\r\nimage = dsa.WrapDataObject(rt.GetOutput())\r\nrtdata = image.PointData['RTData']\r\nrtmin = algs.min(rtdata)\r\nrtmax = algs.max(rtdata)\r\nrtnorm = (rtdata - rtmin) / (rtmax - rtmin)\r\nimage.PointData.append(rtnorm, 'RTData - normalized')\r\nprint image.GetPointData().GetArray('RTData - normalized').GetRange()\r\n\r\nTo calculate gradient:\r\n\r\ngrad= algs.gradient(rtnorm)\r\n\r\nTo access subsets:\r\n\r\n>>> grad[0:10]\r\nVTKArray([[ 0.10729134,  0.03763443,  0.03136338],\r\n       [ 0.02754352,  0.03886006,  0.032589  ],\r\n       [ 0.02248248,  0.04127144,  0.03500038],\r\n       [ 0.02678365,  0.04357527,  0.03730421],\r\n       [ 0.01765099,  0.04571581,  0.03944477],\r\n       [ 0.02344007,  0.04763837,  0.04136734],\r\n       [ 0.01089381,  0.04929155,  0.04302051],\r\n       [ 0.01769151,  0.05062952,  0.04435848],\r\n       [ 0.002764  ,  0.05161414,  0.04534309],\r\n       [ 0.01010841,  0.05221677,  0.04594573]])\r\n\r\n>>> grad[:, 0]\r\nVTKArray([ 0.10729134,  0.02754352,  0.02248248, ..., -0.02748174,\r\n       -0.02410045,  0.05509736])\r\n\r\nAll of this functionality is also supported for composite datasets\r\neven though their data arrays may be spread across multiple datasets.\r\nWe have implemented a VTKCompositeDataArray class that handles many\r\nNumpy style operators and is supported by all algorithms in the\r\nalgorithms module.\r\n\r\nThis module also provides an API to access composite datasets.\r\nFor example:\r\n\r\nmb = vtk.vtkMultiBlockDataSet()\r\nmb.SetBlock(0, image.VTKObject)\r\nmb.SetBlock(1e, image.VTKObject)\r\ncds = dsa.WrapDataObject(mb)\r\nfor block in cds:\r\n    print block\r\n\r\nNote that this module implements only the wrappers for datasets\r\nand arrays. The classes implement many useful operators. However,\r\nto make best use of these classes, take a look at the algorithms\r\nmodule.\r\n\"\"\"\r\ntry:\r\n    import numpy\r\nexcept ImportError:\r\n    raise RuntimeError(\"This module depends on the numpy module. Please make\\\r\nsure that it is installed properly.\")\r\n\r\nimport itertools\r\nimport operator\r\nimport sys\r\nfrom vtk import buffer_shared\r\nfrom vtk.util import numpy_support\r\nfrom vtk.vtkCommonDataModel import vtkDataObject\r\nimport weakref\r\n\r\nif sys.hexversion < 0x03000000:\r\n    izip = itertools.izip\r\nelse:\r\n    izip = zip\r\n\r\ndef reshape_append_ones (a1, a2):\r\n    \"\"\"Returns a list with the two arguments, any of them may be\r\n    processed.  If the arguments are numpy.ndarrays, append 1s to the\r\n    shape of the array with the smallest number of dimensions until\r\n    the arrays have the same number of dimensions. Does nothing if the\r\n    arguments are not ndarrays or the arrays have the same number of\r\n    dimensions.\r\n\r\n    \"\"\"\r\n    l = [a1, a2]\r\n    if (isinstance(a1, numpy.ndarray) and isinstance(a2, numpy.ndarray)):\r\n        len1 = len(a1.shape)\r\n        len2 = len(a2.shape)\r\n        if (len1 == len2 or len1 == 0 or len2 == 0 or\r\n            a1.shape[0] != a2.shape[0]):\r\n            return l;\r\n        elif (len1 < len2):\r\n            d = len1\r\n            maxLength = len2\r\n            i = 0\r\n        else:\r\n            d = len2\r\n            maxLength = len1\r\n            i = 1\r\n        while (d < maxLength):\r\n            l[i] = numpy.expand_dims(l[i], d)\r\n            d = d + 1\r\n    return l\r\n\r\nclass ArrayAssociation :\r\n    \"\"\"Easy access to vtkDataObject.AttributeTypes\"\"\"\r\n    POINT = vtkDataObject.POINT\r\n    CELL  = vtkDataObject.CELL\r\n    FIELD = vtkDataObject.FIELD\r\n    ROW = vtkDataObject.ROW\r\n\r\nclass VTKObjectWrapper(object):\r\n    \"\"\"Superclass for classes that wrap VTK objects with Python objects.\r\n    This class holds a reference to the wrapped VTK object. It also\r\n    forwards unresolved methods to the underlying object by overloading\r\n    __get__attr.\"\"\"\r\n    def __init__(self, vtkobject):\r\n        self.VTKObject = vtkobject\r\n\r\n    def __getattr__(self, name):\r\n        \"Forwards unknown attribute requests to VTK object.\"\r\n        return getattr(self.VTKObject, name)\r\n\r\ndef _MakeObserver(numpy_array):\r\n    \"Internal function used to attach a numpy array to a vtk array\"\r\n    def Closure(caller, event):\r\n        foo = numpy_array\r\n    return Closure\r\n\r\ndef vtkDataArrayToVTKArray(array, dataset=None):\r\n    \"Given a vtkDataArray and a dataset owning it, returns a VTKArray.\"\r\n    narray = numpy_support.vtk_to_numpy(array)\r\n\r\n    # Make arrays of 9 components into matrices. Also transpose\r\n    # as VTK store matrices in Fortran order\r\n    shape = narray.shape\r\n    if len(shape) == 2 and shape[1] == 9:\r\n        narray = narray.reshape((shape[0], 3, 3)).transpose(0, 2, 1)\r\n\r\n    return VTKArray(narray, array=array, dataset=dataset)\r\n\r\ndef numpyTovtkDataArray(array, name=\"numpy_array\", array_type=None):\r\n    \"\"\"Given a numpy array or a VTKArray and a name, returns a vtkDataArray.\r\n    The resulting vtkDataArray will store a reference to the numpy array\r\n    through a DeleteEvent observer: the numpy array is released only when\r\n    the vtkDataArray is destroyed.\"\"\"\r\n    if not array.flags.contiguous:\r\n        array = array.copy()\r\n    vtkarray = numpy_support.numpy_to_vtk(array, array_type=array_type)\r\n    vtkarray.SetName(name)\r\n    # This makes the VTK array carry a reference to the numpy array.\r\n    vtkarray.AddObserver('DeleteEvent', _MakeObserver(array))\r\n    return vtkarray\r\n\r\ndef _make_tensor_array_contiguous(array):\r\n    if array is None:\r\n        return None\r\n    if array.flags.contiguous:\r\n        return array\r\n    array = numpy.asarray(array)\r\n    size = array.dtype.itemsize\r\n    strides = array.strides\r\n    if len(strides) == 3 and strides[1]/size == 1 and strides[2]/size == 3:\r\n        return array.transpose(0, 2, 1)\r\n    return array\r\n\r\ndef _metaclass(mcs):\r\n    \"\"\"For compatibility between python 2 and python 3.\"\"\"\r\n    def decorator(cls):\r\n        body = vars(cls).copy()\r\n        body.pop('__dict__', None)\r\n        body.pop('__weakref__', None)\r\n        return mcs(cls.__name__, cls.__bases__, body)\r\n    return decorator\r\n\r\nclass VTKArrayMetaClass(type):\r\n    def __new__(mcs, name, parent, attr):\r\n        \"\"\"We overwrite numerical/comparison operators because we might need\r\n        to reshape one of the arrays to perform the operation without\r\n        broadcast errors. For instace:\r\n\r\n        An array G of shape (n,3) resulted from computing the\r\n        gradient on a scalar array S of shape (n,) cannot be added together without\r\n        reshaping.\r\n        G + expand_dims(S,1) works,\r\n        G + S gives an error:\r\n        ValueError: operands could not be broadcast together with shapes (n,3) (n,)\r\n\r\n        This metaclass overwrites operators such that it computes this\r\n        reshape operation automatically by appending 1s to the\r\n        dimensions of the array with fewer dimensions.\r\n\r\n        \"\"\"\r\n        def add_numeric_op(attr_name):\r\n            \"\"\"Create an attribute named attr_name that calls\r\n            _numeric_op(self, other, op).\"\"\"\r\n            def closure(self, other):\r\n                return VTKArray._numeric_op(self, other, attr_name)\r\n            closure.__name__ = attr_name\r\n            attr[attr_name] = closure\r\n\r\n        def add_default_numeric_op(op_name):\r\n            \"\"\"Adds '__[op_name]__' attribute that uses operator.[op_name]\"\"\"\r\n            add_numeric_op(\"__%s__\"%op_name)\r\n\r\n        def add_reverse_numeric_op(attr_name):\r\n            \"\"\"Create an attribute named attr_name that calls\r\n            _reverse_numeric_op(self, other, op).\"\"\"\r\n            def closure(self, other):\r\n                return VTKArray._reverse_numeric_op(self, other, attr_name)\r\n            closure.__name__ = attr_name\r\n            attr[attr_name] = closure\r\n\r\n        def add_default_reverse_numeric_op(op_name):\r\n            \"\"\"Adds '__r[op_name]__' attribute that uses operator.[op_name]\"\"\"\r\n            add_reverse_numeric_op(\"__r%s__\"%op_name)\r\n\r\n        def add_default_numeric_ops(op_name):\r\n            \"\"\"Call both add_default_numeric_op and add_default_reverse_numeric_op.\"\"\"\r\n            add_default_numeric_op(op_name)\r\n            add_default_reverse_numeric_op(op_name)\r\n\r\n        add_default_numeric_ops(\"add\")\r\n        add_default_numeric_ops(\"sub\")\r\n        add_default_numeric_ops(\"mul\")\r\n        if sys.hexversion < 0x03000000:\r\n            add_default_numeric_ops(\"div\")\r\n        add_default_numeric_ops(\"truediv\")\r\n        add_default_numeric_ops(\"floordiv\")\r\n        add_default_numeric_ops(\"mod\")\r\n        add_default_numeric_ops(\"pow\")\r\n        add_default_numeric_ops(\"lshift\")\r\n        add_default_numeric_ops(\"rshift\")\r\n        add_numeric_op(\"and\")\r\n        add_default_numeric_ops(\"xor\")\r\n        add_numeric_op(\"or\")\r\n\r\n        add_default_numeric_op(\"lt\")\r\n        add_default_numeric_op(\"le\")\r\n        add_default_numeric_op(\"eq\")\r\n        add_default_numeric_op(\"ne\")\r\n        add_default_numeric_op(\"ge\")\r\n        add_default_numeric_op(\"gt\")\r\n        return type.__new__(mcs, name, parent, attr)\r\n\r\n@_metaclass(VTKArrayMetaClass)\r\nclass VTKArray(numpy.ndarray):\r\n    \"\"\"This is a sub-class of numpy ndarray that stores a\r\n    reference to a vtk array as well as the owning dataset.\r\n    The numpy array and vtk array should point to the same\r\n    memory location.\"\"\"\r\n\r\n    def _numeric_op(self, other, attr_name):\r\n        \"\"\"Used to implement numpy-style numerical operations such as __add__,\r\n        __mul__, etc.\"\"\"\r\n        l = reshape_append_ones(self, other)\r\n        return getattr(numpy.ndarray, attr_name)(l[0], l[1])\r\n\r\n    def _reverse_numeric_op(self, other, attr_name):\r\n        \"\"\"Used to implement numpy-style numerical operations such as __add__,\r\n        __mul__, etc.\"\"\"\r\n        l = reshape_append_ones(self, other)\r\n        return getattr(numpy.ndarray, attr_name)(l[0], l[1])\r\n\r\n    def __new__(cls, input_array, array=None, dataset=None):\r\n        # Input array is an already formed ndarray instance\r\n        # We first cast to be our class type\r\n        obj = numpy.asarray(input_array).view(cls)\r\n        obj.Association = ArrayAssociation.FIELD\r\n        # add the new attributes to the created instance\r\n        obj.VTKObject = array\r\n        # if dataset:\r\n        #     import weakref\r\n        #     obj.DataSet = weakref.ref(dataset)\r\n        obj.DataSet = dataset\r\n        # Finally, we must return the newly created object:\r\n        return obj\r\n\r\n    def __array_finalize__(self,obj):\r\n        # Copy the VTK array only if the two share data\r\n        slf = _make_tensor_array_contiguous(self)\r\n        obj2 = _make_tensor_array_contiguous(obj)\r\n\r\n        self.VTKObject = None\r\n        try:\r\n            # This line tells us that they are referring to the same buffer.\r\n            # Much like two pointers referring to same memory location in C/C++.\r\n            if buffer_shared(slf, obj2):\r\n                self.VTKObject = getattr(obj, 'VTKObject', None)\r\n        except TypeError:\r\n            pass\r\n\r\n        self.Association = getattr(obj, 'Association', None)\r\n        self.DataSet = getattr(obj, 'DataSet', None)\r\n\r\n    def __getattr__(self, name):\r\n        \"Forwards unknown attribute requests to VTK array.\"\r\n        try:\r\n            o = self.__dict__[\"VTKObject\"]\r\n        except KeyError:\r\n            o = None\r\n        if o is None:\r\n            raise AttributeError(\"'%s' object has no attribute '%s'\" %\r\n                                 (self.__class__.__name__, name))\r\n        return getattr(o, name)\r\n\r\nclass VTKNoneArrayMetaClass(type):\r\n    def __new__(mcs, name, parent, attr):\r\n        \"\"\"Simplify the implementation of the numeric/logical sequence API.\"\"\"\r\n        def _add_op(attr_name, op):\r\n            \"\"\"Create an attribute named attr_name that calls\r\n            _numeric_op(self, other, op).\"\"\"\r\n            def closure(self, other):\r\n                return VTKNoneArray._op(self, other, op)\r\n            closure.__name__ = attr_name\r\n            attr[attr_name] = closure\r\n\r\n        def _add_default_reverse_op(op_name):\r\n            \"\"\"Adds '__r[op_name]__' attribute that uses operator.[op_name]\"\"\"\r\n            _add_op(\"__r%s__\"%op_name, getattr(operator, op_name))\r\n\r\n        def _add_default_op(op_name):\r\n            \"\"\"Adds '__[op_name]__' attribute that uses operator.[op_name]\"\"\"\r\n            _add_op(\"__%s__\"%op_name, getattr(operator, op_name))\r\n\r\n        def _add_default_ops(op_name):\r\n            \"\"\"Call both add_default_numeric_op and add_default_reverse_numeric_op.\"\"\"\r\n            _add_default_op(op_name)\r\n            _add_default_reverse_op(op_name)\r\n\r\n        _add_default_ops(\"add\")\r\n        _add_default_ops(\"sub\")\r\n        _add_default_ops(\"mul\")\r\n        if sys.hexversion < 0x03000000:\r\n            _add_default_ops(\"div\")\r\n        _add_default_ops(\"truediv\")\r\n        _add_default_ops(\"floordiv\")\r\n        _add_default_ops(\"mod\")\r\n        _add_default_ops(\"pow\")\r\n        _add_default_ops(\"lshift\")\r\n        _add_default_ops(\"rshift\")\r\n        _add_op(\"__and__\", operator.and_)\r\n        _add_op(\"__rand__\", operator.and_)\r\n        _add_default_ops(\"xor\")\r\n        _add_op(\"__or__\", operator.or_)\r\n        _add_op(\"__ror__\", operator.or_)\r\n\r\n        _add_default_op(\"lt\")\r\n        _add_default_op(\"le\")\r\n        _add_default_op(\"eq\")\r\n        _add_default_op(\"ne\")\r\n        _add_default_op(\"ge\")\r\n        _add_default_op(\"gt\")\r\n        return type.__new__(mcs, name, parent, attr)\r\n\r\n@_metaclass(VTKNoneArrayMetaClass)\r\nclass VTKNoneArray(object):\r\n    \"\"\"VTKNoneArray is used to represent a \"void\" array. An instance\r\n    of this class (NoneArray) is returned instead of None when an\r\n    array that doesn't exist in a DataSetAttributes is requested.\r\n    All operations on the NoneArray return NoneArray. The main reason\r\n    for this is to support operations in parallel where one of the\r\n    processes may be working on an empty dataset. In such cases,\r\n    the process is still expected to evaluate a whole expression because\r\n    some of the functions may perform bulk MPI communication. None\r\n    cannot be used in these instances because it cannot properly override\r\n    operators such as __add__, __sub__ etc. This is the main raison\r\n    d'etre for VTKNoneArray.\"\"\"\r\n\r\n    def __getitem__(self, index):\r\n        return NoneArray\r\n\r\n    def _op(self, other, op):\r\n        \"\"\"Used to implement numpy-style numerical operations such as __add__,\r\n        __mul__, etc.\"\"\"\r\n        return NoneArray\r\n\r\n    def astype(self, dtype):\r\n        \"\"\"Implements numpy array's astype method.\"\"\"\r\n        return NoneArray\r\n\r\nNoneArray = VTKNoneArray()\r\n\r\nclass VTKCompositeDataArrayMetaClass(type):\r\n    def __new__(mcs, name, parent, attr):\r\n        \"\"\"Simplify the implementation of the numeric/logical sequence API.\"\"\"\r\n        def add_numeric_op(attr_name, op):\r\n            \"\"\"Create an attribute named attr_name that calls\r\n            _numeric_op(self, other, op).\"\"\"\r\n            def closure(self, other):\r\n                return VTKCompositeDataArray._numeric_op(self, other, op)\r\n            closure.__name__ = attr_name\r\n            attr[attr_name] = closure\r\n\r\n        def add_reverse_numeric_op(attr_name, op):\r\n            \"\"\"Create an attribute named attr_name that calls\r\n            _reverse_numeric_op(self, other, op).\"\"\"\r\n            def closure(self, other):\r\n                return VTKCompositeDataArray._reverse_numeric_op(self, other, op)\r\n            closure.__name__ = attr_name\r\n            attr[attr_name] = closure\r\n\r\n        def add_default_reverse_numeric_op(op_name):\r\n            \"\"\"Adds '__r[op_name]__' attribute that uses operator.[op_name]\"\"\"\r\n            add_reverse_numeric_op(\"__r%s__\"%op_name, getattr(operator, op_name))\r\n\r\n        def add_default_numeric_op(op_name):\r\n            \"\"\"Adds '__[op_name]__' attribute that uses operator.[op_name]\"\"\"\r\n            add_numeric_op(\"__%s__\"%op_name, getattr(operator, op_name))\r\n\r\n        def add_default_numeric_ops(op_name):\r\n            \"\"\"Call both add_default_numeric_op and add_default_reverse_numeric_op.\"\"\"\r\n            add_default_numeric_op(op_name)\r\n            add_default_reverse_numeric_op(op_name)\r\n\r\n        add_default_numeric_ops(\"add\")\r\n        add_default_numeric_ops(\"sub\")\r\n        add_default_numeric_ops(\"mul\")\r\n        if sys.hexversion < 0x03000000:\r\n            add_default_numeric_ops(\"div\")\r\n        add_default_numeric_ops(\"truediv\")\r\n        add_default_numeric_ops(\"floordiv\")\r\n        add_default_numeric_ops(\"mod\")\r\n        add_default_numeric_ops(\"pow\")\r\n        add_default_numeric_ops(\"lshift\")\r\n        add_default_numeric_ops(\"rshift\")\r\n        add_numeric_op(\"__and__\", operator.and_)\r\n        add_reverse_numeric_op(\"__rand__\", operator.and_)\r\n        add_default_numeric_ops(\"xor\")\r\n        add_numeric_op(\"__or__\", operator.or_)\r\n        add_reverse_numeric_op(\"__ror__\", operator.or_)\r\n\r\n        add_default_numeric_op(\"lt\")\r\n        add_default_numeric_op(\"le\")\r\n        add_default_numeric_op(\"eq\")\r\n        add_default_numeric_op(\"ne\")\r\n        add_default_numeric_op(\"ge\")\r\n        add_default_numeric_op(\"gt\")\r\n        return type.__new__(mcs, name, parent, attr)\r\n\r\n@_metaclass(VTKCompositeDataArrayMetaClass)\r\nclass VTKCompositeDataArray(object):\r\n    \"\"\"This class manages a set of arrays of the same name contained\r\n    within a composite dataset. Its main purpose is to provide a\r\n    Numpy-type interface to composite data arrays which are naturally\r\n    nothing but a collection of vtkDataArrays. A VTKCompositeDataArray\r\n    makes such a collection appear as a single Numpy array and support\r\n    all array operations that this module and the associated algorithm\r\n    module support. Note that this is not a subclass of a Numpy array\r\n    and as such cannot be passed to native Numpy functions. Instead\r\n    VTK modules should be used to process composite arrays.\r\n    \"\"\"\r\n\r\n    def __init__(self, arrays = [], dataset = None, name = None,\r\n                 association = ArrayAssociation.FIELD):\r\n        \"\"\"Construct a composite array given a container of\r\n        arrays, a dataset, name and association. It is sufficient\r\n        to define a container of arrays to define a composite array.\r\n        It is also possible to initialize an array by defining\r\n        the dataset, name and array association. In that case,\r\n        the underlying arrays will be created lazily when they\r\n        are needed. It is recommended to use the latter method\r\n        when initializing from an existing composite dataset.\"\"\"\r\n        self._Arrays = arrays\r\n        self.DataSet = dataset\r\n        self.Name = name\r\n        self.Association = association\r\n        self.Initialized = False\r\n\r\n    def __init_from_composite(self):\r\n        if self.Initialized:\r\n            return\r\n\r\n        self.Initialized = True\r\n\r\n        if self.DataSet is None or self.Name is None:\r\n            return\r\n\r\n        self._Arrays = []\r\n        for ds in self.DataSet:\r\n            self._Arrays.append(ds.GetAttributes(self.Association)[self.Name])\r\n\r\n    def GetSize(self):\r\n        \"Returns the number of elements in the array.\"\r\n        self.__init_from_composite()\r\n        size = numpy.int64(0)\r\n        for a in self._Arrays:\r\n            try:\r\n                size += a.size\r\n            except AttributeError:\r\n                pass\r\n        return size\r\n\r\n    size = property(GetSize)\r\n\r\n    def GetArrays(self):\r\n        \"\"\"Returns the internal container of VTKArrays. If necessary,\r\n        this will populate the array list from a composite dataset.\"\"\"\r\n        self.__init_from_composite()\r\n        return self._Arrays\r\n\r\n    Arrays = property(GetArrays)\r\n\r\n    def __getitem__(self, index):\r\n        \"\"\"Overwritten to refer indexing to underlying VTKArrays.\r\n        For the most part, this will behave like Numpy. Note\r\n        that indexing is done per array - arrays are never treated\r\n        as forming a bigger array. If the index is another composite\r\n        array, a one-to-one mapping between arrays is assumed.\r\n        \"\"\"\r\n        self.__init_from_composite()\r\n        res = []\r\n        if type(index) == VTKCompositeDataArray:\r\n            for a, idx in izip(self._Arrays, index.Arrays):\r\n                if a is not NoneArray:\r\n                    res.append(a.__getitem__(idx))\r\n                else:\r\n                    res.append(NoneArray)\r\n        else:\r\n            for a in self._Arrays:\r\n                if a is not NoneArray:\r\n                    res.append(a.__getitem__(index))\r\n                else:\r\n                    res.append(NoneArray)\r\n        return VTKCompositeDataArray(res, dataset=self.DataSet)\r\n\r\n    def _numeric_op(self, other, op):\r\n        \"\"\"Used to implement numpy-style numerical operations such as __add__,\r\n        __mul__, etc.\"\"\"\r\n        self.__init_from_composite()\r\n        res = []\r\n        if type(other) == VTKCompositeDataArray:\r\n            for a1, a2 in izip(self._Arrays, other.Arrays):\r\n                if a1 is not NoneArray and a2 is not NoneArray:\r\n                    l = reshape_append_ones(a1, a2)\r\n                    res.append(op(l[0],l[1]))\r\n                else:\r\n                    res.append(NoneArray)\r\n        else:\r\n            for a in self._Arrays:\r\n                if a is not NoneArray:\r\n                    l = reshape_append_ones(a, other)\r\n                    res.append(op(l[0], l[1]))\r\n                else:\r\n                    res.append(NoneArray)\r\n        return VTKCompositeDataArray(res, dataset=self.DataSet)\r\n\r\n    def _reverse_numeric_op(self, other, op):\r\n        \"\"\"Used to implement numpy-style numerical operations such as __add__,\r\n        __mul__, etc.\"\"\"\r\n        self.__init_from_composite()\r\n        res = []\r\n        if type(other) == VTKCompositeDataArray:\r\n            for a1, a2 in izip(self._Arrays, other.Arrays):\r\n                if a1 is not NoneArray and a2 is notNoneArray:\r\n                    l = reshape_append_ones(a2,a1)\r\n                    res.append(op(l[0],l[1]))\r\n                else:\r\n                    res.append(NoneArray)\r\n        else:\r\n            for a in self._Arrays:\r\n                if a is not NoneArray:\r\n                    l = reshape_append_ones(other, a)\r\n                    res.append(op(l[0], l[1]))\r\n                else:\r\n                    res.append(NoneArray)\r\n        return VTKCompositeDataArray(res, dataset=self.DataSet)\r\n\r\n    def __str__(self):\r\n        return self.Arrays.__str__()\r\n\r\n    def astype(self, dtype):\r\n        \"\"\"Implements numpy array's as array method.\"\"\"\r\n        res = []\r\n        if self is not NoneArray:\r\n            for a in self.Arrays:\r\n                if a is NoneArray:\r\n                    res.append(NoneArray)\r\n                else:\r\n                    res.append(a.astype(dtype))\r\n        return VTKCompositeDataArray(res, dataset = self.DataSet)\r\n\r\n\r\nclass DataSetAttributes(VTKObjectWrapper):\r\n    \"\"\"This is a python friendly wrapper of vtkDataSetAttributes. It\r\n    returns VTKArrays. It also provides the dictionary interface.\"\"\"\r\n\r\n    def __init__(self, vtkobject, dataset, association):\r\n        super(DataSetAttributes, self).__init__(vtkobject)\r\n        # import weakref\r\n        # self.DataSet = weakref.ref(dataset)\r\n        self.DataSet = dataset\r\n        self.Association = association\r\n\r\n    def __getitem__(self, idx):\r\n        \"\"\"Implements the [] operator. Accepts an array name or index.\"\"\"\r\n        return self.GetArray(idx)\r\n\r\n    def GetArray(self, idx):\r\n        \"Given an index or name, returns a VTKArray.\"\r\n        if isinstance(idx, int) and idx >= self.VTKObject.GetNumberOfArrays():\r\n            raise IndexError(\"array index out of range\")\r\n        vtkarray = self.VTKObject.GetArray(idx)\r\n        if not vtkarray:\r\n            vtkarray = self.VTKObject.GetAbstractArray(idx)\r\n            if vtkarray:\r\n                return vtkarray\r\n            return NoneArray\r\n        array = vtkDataArrayToVTKArray(vtkarray, self.DataSet)\r\n        array.Association = self.Association\r\n        return array\r\n\r\n    def keys(self):\r\n        \"\"\"Returns the names of the arrays as a list.\"\"\"\r\n        kys = []\r\n        narrays = self.VTKObject.GetNumberOfArrays()\r\n        for i in range(narrays):\r\n            name = self.VTKObject.GetAbstractArray(i).GetName()\r\n            if name:\r\n                kys.append(name)\r\n        return kys\r\n\r\n    def values(self):\r\n        \"\"\"Returns the arrays as a list.\"\"\"\r\n        vals = []\r\n        narrays = self.VTKObject.GetNumberOfArrays()\r\n        for i in range(narrays):\r\n            a = self.VTKObject.GetAbstractArray(i)\r\n            if a.GetName():\r\n                vals.append(a)\r\n        return vals\r\n\r\n    def PassData(self, other):\r\n        \"A wrapper for vtkDataSet.PassData.\"\r\n        try:\r\n            self.VTKObject.PassData(other)\r\n        except TypeError:\r\n            self.VTKObject.PassData(other.VTKObject)\r\n\r\n    def append(self, narray, name):\r\n        \"\"\"Appends a new array to the dataset attributes.\"\"\"\r\n        if narray is NoneArray:\r\n            # if NoneArray, nothing to do.\r\n            return\r\n\r\n        if self.Association == ArrayAssociation.POINT:\r\n            arrLength = self.DataSet.GetNumberOfPoints()\r\n        elif self.Association == ArrayAssociation.CELL:\r\n            arrLength = self.DataSet.GetNumberOfCells()\r\n        else:\r\n            if not isinstance(narray, numpy.ndarray):\r\n                arrLength = 1\r\n            else:\r\n                arrLength = narray.shape[0]\r\n\r\n        # Fixup input array length:\r\n        if not isinstance(narray, numpy.ndarray) or numpy.ndim(narray) == 0: # Scalar input\r\n            narray = narray * numpy.ones(arrLength)\r\n        elif narray.shape[0] != arrLength: # Vector input\r\n            components = 1\r\n            for l in narray.shape:\r\n                components *= l\r\n            narray = narray.flatten() * numpy.ones((arrLength, components))\r\n\r\n        shape = narray.shape\r\n\r\n        if len(shape) == 3:\r\n            # Array of matrices. We need to make sure the order  in memory is right.\r\n            # If column order (c order), transpose. VTK wants row order (fortran\r\n            # order). The deep copy later will make sure that the array is contiguous.\r\n            # If row order but not contiguous, transpose so that the deep copy below\r\n            # does not happen.\r\n            size = narray.dtype.itemsize\r\n            if (narray.strides[1]/size == 3 and narray.strides[2]/size == 1) or \\\r\n                (narray.strides[1]/size == 1 and narray.strides[2]/size == 3 and \\\r\n                 not narray.flags.contiguous):\r\n                narray  = narray.transpose(0, 2, 1)\r\n\r\n        # If array is not contiguous, make a deep copy that is contiguous\r\n        if not narray.flags.contiguous:\r\n            narray = narray.copy()\r\n\r\n        # Flatten array of matrices to array of vectors\r\n        if len(shape) == 3:\r\n            narray = narray.reshape(shape[0], shape[1]*shape[2])\r\n\r\n        # this handle the case when an input array is directly appended on the\r\n        # output. We want to make sure that the array added to the output is not\r\n        # referring to the input dataset.\r\n        copy = VTKArray(narray)\r\n        try:\r\n            copy.VTKObject = narray.VTKObject\r\n        except AttributeError: pass\r\n        arr = numpyTovtkDataArray(copy, name)\r\n        self.VTKObject.AddArray(arr)\r\n\r\n\r\nclass CompositeDataSetAttributes():\r\n    \"\"\"This is a python friendly wrapper for vtkDataSetAttributes for composite\r\n    datsets. Since composite datasets themselves don't have attribute data, but\r\n    the attribute data is associated with the leaf nodes in the composite\r\n    dataset, this class simulates a DataSetAttributes interface by taking a\r\n    union of DataSetAttributes associated with all leaf nodes.\"\"\"\r\n\r\n    def __init__(self, dataset, association):\r\n        # import weakref\r\n        # self.DataSet = weakref.ref(dataset)\r\n        self.DataSet = dataset\r\n        self.Association = association\r\n        self.ArrayNames = []\r\n        self.Arrays = {}\r\n\r\n        # build the set of arrays available in the composite dataset. Since\r\n        # composite datasets can have partial arrays, we need to iterate over\r\n        # all non-null blocks in the dataset.\r\n        self.__determine_arraynames()\r\n\r\n    def __determine_arraynames(self):\r\n        array_set = set()\r\n        array_list = []\r\n        for dataset in self.DataSet:\r\n            dsa = dataset.GetAttributes(self.Association)\r\n            for array_name in dsa.keys():\r\n                if array_name not in array_set:\r\n                    array_set.add(array_name)\r\n                    array_list.append(array_name)\r\n        self.ArrayNames = array_list\r\n\r\n    def keys(self):\r\n        \"\"\"Returns the names of the arrays as a list.\"\"\"\r\n        return self.ArrayNames\r\n\r\n    def __getitem__(self, idx):\r\n        \"\"\"Implements the [] operator. Accepts an array name.\"\"\"\r\n        return self.GetArray(idx)\r\n\r\n    def append(self, narray, name):\r\n        \"\"\"Appends a new array to the composite dataset attributes.\"\"\"\r\n        if narray is NoneArray:\r\n            # if NoneArray, nothing to do.\r\n            return\r\n\r\n        added = False\r\n        if not isinstance(narray, VTKCompositeDataArray): # Scalar input\r\n            for ds in self.DataSet:\r\n                ds.GetAttributes(self.Association).append(narray, name)\r\n                added = True\r\n            if added:\r\n                self.ArrayNames.append(name)\r\n                # don't add the narray since it's a scalar. GetArray() will create a\r\n                # VTKCompositeArray on-demand.\r\n        else:\r\n            for ds, array in izip(self.DataSet, narray.Arrays):\r\n                if array is not None:\r\n                    ds.GetAttributes(self.Association).append(array, name)\r\n                    added = True\r\n            if added:\r\n                self.ArrayNames.append(name)\r\n                self.Arrays[name] = weakref.ref(narray)\r\n\r\n    def GetArray(self, idx):\r\n        \"\"\"Given a name, returns a VTKCompositeArray.\"\"\"\r\n        arrayname = idx\r\n        if arrayname not in self.ArrayNames:\r\n            return NoneArray\r\n        if arrayname not in self.Arrays or self.Arrays[arrayname]() is None:\r\n            array = VTKCompositeDataArray(\r\n                dataset = self.DataSet, name = arrayname, association = self.Association)\r\n            self.Arrays[arrayname] = weakref.ref(array)\r\n        else:\r\n            array = self.Arrays[arrayname]()\r\n        return array\r\n\r\n    def PassData(self, other):\r\n        \"\"\"Emulate PassData for composite datasets.\"\"\"\r\n        for this,that in zip(self.DataSet, other.DataSet):\r\n            for assoc in [ArrayAssociation.POINT, ArrayAssociation.CELL]:\r\n                this.GetAttributes(assoc).PassData(that.GetAttributes(assoc))\r\n\r\nclass CompositeDataIterator(object):\r\n    \"\"\"Wrapper for a vtkCompositeDataIterator class to satisfy\r\n       the python iterator protocol. This iterator iterates\r\n       over non-empty leaf nodes. To iterate over empty or\r\n       non-leaf nodes, use the vtkCompositeDataIterator directly.\r\n       \"\"\"\r\n\r\n    def __init__(self, cds):\r\n        self.Iterator = cds.NewIterator()\r\n        if self.Iterator:\r\n            self.Iterator.UnRegister(None)\r\n            self.Iterator.GoToFirstItem()\r\n\r\n    def __iter__(self):\r\n        return self\r\n\r\n    def __next__(self):\r\n        if not self.Iterator:\r\n            raise StopIteration\r\n\r\n        if self.Iterator.IsDoneWithTraversal():\r\n            raise StopIteration\r\n        retVal = self.Iterator.GetCurrentDataObject()\r\n        self.Iterator.GoToNextItem()\r\n        return WrapDataObject(retVal)\r\n\r\n    def next(self):\r\n        return self.__next__()\r\n\r\n    def __getattr__(self, name):\r\n        \"\"\"Returns attributes from the vtkCompositeDataIterator.\"\"\"\r\n        return getattr(self.Iterator, name)\r\n\r\nclass MultiCompositeDataIterator(CompositeDataIterator):\r\n    \"\"\"Iterator that can be used to iterate over multiple\r\n    composite datasets together. This iterator works only\r\n    with arrays that were copied from an original using\r\n    CopyStructured. The most common use case is to use\r\n    CopyStructure, then iterate over input and output together\r\n    while creating output datasets from corresponding input\r\n    datasets.\"\"\"\r\n    def __init__(self, cds):\r\n        CompositeDataIterator.__init__(self, cds[0])\r\n        self.Datasets = cds\r\n\r\n    def __next__(self):\r\n        if not self.Iterator:\r\n            raise StopIteration\r\n\r\n        if self.Iterator.IsDoneWithTraversal():\r\n            raise StopIteration\r\n        retVal = []\r\n        retVal.append(WrapDataObject(self.Iterator.GetCurrentDataObject()))\r\n        if len(self.Datasets) > 1:\r\n            for cd in self.Datasets[1:]:\r\n                retVal.append(WrapDataObject(cd.GetDataSet(self.Iterator)))\r\n        self.Iterator.GoToNextItem()\r\n        return retVal\r\n\r\n    def next(self):\r\n        return self.__next__()\r\n\r\nclass DataObject(VTKObjectWrapper):\r\n    \"\"\"A wrapper for vtkDataObject that makes it easier to access FielData\r\n    arrays as VTKArrays\r\n    \"\"\"\r\n\r\n    def GetAttributes(self, type):\r\n        \"\"\"Returns the attributes specified by the type as a DataSetAttributes\r\n         instance.\"\"\"\r\n        if type == ArrayAssociation.FIELD:\r\n            return DataSetAttributes(self.VTKObject.GetFieldData(), self, type)\r\n        return DataSetAttributes(self.VTKObject.GetAttributes(type), self, type)\r\n\r\n    def GetFieldData(self):\r\n        \"Returns the field data as a DataSetAttributes instance.\"\r\n        return DataSetAttributes(self.VTKObject.GetFieldData(), self, ArrayAssociation.FIELD)\r\n\r\n    FieldData = property(GetFieldData, None, None, \"This property returns the field data of a data object.\")\r\n\r\nclass Table(DataObject):\r\n    \"\"\"A wrapper for vtkFielData that makes it easier to access RowData array as\r\n    VTKArrays\r\n    \"\"\"\r\n    def GetRowData(self):\r\n        \"Returns the row data as a DataSetAttributes instance.\"\r\n        return self.GetAttributes(ArrayAssociation.ROW)\r\n\r\n    RowData = property(GetRowData, None, None, \"This property returns the row data of the table.\")\r\n\r\nclass CompositeDataSet(DataObject):\r\n    \"\"\"A wrapper for vtkCompositeData and subclasses that makes it easier\r\n    to access Point/Cell/Field data as VTKCompositeDataArrays. It also\r\n    provides a Python type iterator.\"\"\"\r\n\r\n    def __init__(self, vtkobject):\r\n        DataObject.__init__(self, vtkobject)\r\n        self._PointData = None\r\n        self._CellData = None\r\n        self._FieldData = None\r\n        self._Points = None\r\n\r\n    def __iter__(self):\r\n        \"Creates an iterator for the contained datasets.\"\r\n        return CompositeDataIterator(self)\r\n\r\n    def GetNumberOfElements(self, assoc):\r\n        \"\"\"Returns the total number of cells or points depending\r\n        on the value of assoc which can be ArrayAssociation.POINT or\r\n        ArrayAssociation.CELL.\"\"\"\r\n        result = 0\r\n        for dataset in self:\r\n            result += dataset.GetNumberOfElements(assoc)\r\n        return int(result)\r\n\r\n    def GetNumberOfPoints(self):\r\n        \"\"\"Returns the total number of points of all datasets\r\n        in the composite dataset. Note that this traverses the\r\n        whole composite dataset every time and should not be\r\n        called repeatedly for large composite datasets.\"\"\"\r\n        return self.GetNumberOfElements(ArrayAssociation.POINT)\r\n\r\n    def GetNumberOfCells(self):\r\n        \"\"\"Returns the total number of cells of all datasets\r\n        in the composite dataset. Note that this traverses the\r\n        whole composite dataset every time and should not be\r\n        called repeatedly for large composite datasets.\"\"\"\r\n        return self.GetNumberOfElements(ArrayAssociation.CELL)\r\n\r\n    def GetAttributes(self, type):\r\n        \"\"\"Returns the attributes specified by the type as a\r\n        CompositeDataSetAttributes instance.\"\"\"\r\n        return CompositeDataSetAttributes(self, type)\r\n\r\n    def GetPointData(self):\r\n        \"Returns the point data as a DataSetAttributes instance.\"\r\n        if self._PointData is None or self._PointData() is None:\r\n            pdata = self.GetAttributes(ArrayAssociation.POINT)\r\n            self._PointData = weakref.ref(pdata)\r\n        return self._PointData()\r\n\r\n    def GetCellData(self):\r\n        \"Returns the cell data as a DataSetAttributes instance.\"\r\n        if self._CellData is None or self._CellData() is None:\r\n            cdata = self.GetAttributes(ArrayAssociation.CELL)\r\n            self._CellData = weakref.ref(cdata)\r\n        return self._CellData()\r\n\r\n    def GetFieldData(self):\r\n        \"Returns the field data as a DataSetAttributes instance.\"\r\n        if self._FieldData is None or self._FieldData() is None:\r\n            fdata = self.GetAttributes(ArrayAssociation.FIELD)\r\n            self._FieldData = weakref.ref(fdata)\r\n        return self._FieldData()\r\n\r\n    def GetPoints(self):\r\n        \"Returns the points as a VTKCompositeDataArray instance.\"\r\n        if self._Points is None or self._Points() is None:\r\n            pts = []\r\n            for ds in self:\r\n                try:\r\n                    _pts = ds.Points\r\n                except AttributeError:\r\n                    _pts = None\r\n\r\n                if _pts is None:\r\n                    pts.append(NoneArray)\r\n                else:\r\n                    pts.append(_pts)\r\n            if len(pts) == 0 or all([a is NoneArray for a in pts]):\r\n                cpts = NoneArray\r\n            else:\r\n                cpts = VTKCompositeDataArray(pts, dataset=self)\r\n            self._Points = weakref.ref(cpts)\r\n        return self._Points()\r\n\r\n    PointData = property(GetPointData, None, None, \"This property returns the point data of the dataset.\")\r\n    CellData = property(GetCellData, None, None, \"This property returns the cell data of a dataset.\")\r\n    FieldData = property(GetFieldData, None, None, \"This property returns the field data of a dataset.\")\r\n    Points = property(GetPoints, None, None, \"This property returns the points of the dataset.\")\r\n\r\nclass DataSet(DataObject):\r\n    \"\"\"This is a python friendly wrapper of a vtkDataSet that defines\r\n    a few useful properties.\"\"\"\r\n\r\n    def GetPointData(self):\r\n        \"Returns the point data as a DataSetAttributes instance.\"\r\n        return self.GetAttributes(ArrayAssociation.POINT)\r\n\r\n    def GetCellData(self):\r\n        \"Returns the cell data as a DataSetAttributes instance.\"\r\n        return self.GetAttributes(ArrayAssociation.CELL)\r\n\r\n    PointData = property(GetPointData, None, None, \"This property returns the point data of the dataset.\")\r\n    CellData = property(GetCellData, None, None, \"This property returns the cell data of a dataset.\")\r\n\r\nclass PointSet(DataSet):\r\n    \"\"\"This is a python friendly wrapper of a vtkPointSet that defines\r\n    a few useful properties.\"\"\"\r\n    def GetPoints(self):\r\n        \"\"\"Returns the points as a VTKArray instance. Returns None if the\r\n        dataset has implicit points.\"\"\"\r\n        if not self.VTKObject.GetPoints():\r\n            return None\r\n        return vtkDataArrayToVTKArray(\r\n            self.VTKObject.GetPoints().GetData(), self)\r\n\r\n    def SetPoints(self, pts):\r\n        \"\"\"Given a VTKArray instance, sets the points of the dataset.\"\"\"\r\n        from vtk.vtkCommonCore import vtkPoints\r\n        if isinstance(pts, vtkPoints):\r\n            p = pts\r\n        else:\r\n            pts = numpyTovtkDataArray(pts)\r\n            p = vtkPoints()\r\n            p.SetData(pts)\r\n        self.VTKObject.SetPoints(p)\r\n\r\n    Points = property(GetPoints, SetPoints, None, \"This property returns the point coordinates of dataset.\")\r\n\r\nclass PolyData(PointSet):\r\n    \"\"\"This is a python friendly wrapper of a vtkPolyData that defines\r\n    a few useful properties.\"\"\"\r\n\r\n    def GetPolygons(self):\r\n        \"\"\"Returns the polys as a VTKArray instance.\"\"\"\r\n        if not self.VTKObject.GetPolys():\r\n            return None\r\n        return vtkDataArrayToVTKArray(\r\n            self.VTKObject.GetPolys().GetData(), self)\r\n\r\n    Polygons = property(GetPolygons, None, None, \"This property returns the connectivity of polygons.\")\r\n\r\nclass UnstructuredGrid(PointSet):\r\n    \"\"\"This is a python friendly wrapper of a vtkUnstructuredGrid that defines\r\n    a few useful properties.\"\"\"\r\n\r\n    def GetCellTypes(self):\r\n        \"\"\"Returns the cell types as a VTKArray instance.\"\"\"\r\n        if not self.VTKObject.GetCellTypesArray():\r\n            return None\r\n        return vtkDataArrayToVTKArray(\r\n            self.VTKObject.GetCellTypesArray(), self)\r\n\r\n    def GetCellLocations(self):\r\n        \"\"\"Returns the cell locations as a VTKArray instance.\"\"\"\r\n        if not self.VTKObject.GetCellLocationsArray():\r\n            return None\r\n        return vtkDataArrayToVTKArray(\r\n            self.VTKObject.GetCellLocationsArray(), self)\r\n\r\n    def GetCells(self):\r\n        \"\"\"Returns the cells as a VTKArray instance.\"\"\"\r\n        if not self.VTKObject.GetCells():\r\n            return None\r\n        return vtkDataArrayToVTKArray(\r\n            self.VTKObject.GetCells().GetData(), self)\r\n\r\n    def SetCells(self, cellTypes, cellLocations, cells):\r\n        \"\"\"Given cellTypes, cellLocations, cells as VTKArrays,\r\n        populates the unstructured grid data structures.\"\"\"\r\n        from vtk import VTK_ID_TYPE\r\n        from vtk.vtkCommonDataModel import vtkCellArray\r\n        cellTypes = numpyTovtkDataArray(cellTypes)\r\n        cellLocations = numpyTovtkDataArray(cellLocations, array_type=VTK_ID_TYPE)\r\n        cells = numpyTovtkDataArray(cells, array_type=VTK_ID_TYPE)\r\n        ca = vtkCellArray()\r\n        ca.SetCells(cellTypes.GetNumberOfTuples(), cells)\r\n        self.VTKObject.SetCells(cellTypes, cellLocations, ca)\r\n\r\n    CellTypes = property(GetCellTypes, None, None, \"This property returns the types of cells.\")\r\n    CellLocations = property(GetCellLocations, None, None, \"This property returns the locations of cells.\")\r\n    Cells = property(GetCells, None, None, \"This property returns the connectivity of cells.\")\r\n\r\ndef WrapDataObject(ds):\r\n    \"\"\"Returns a Numpy friendly wrapper of a vtkDataObject.\"\"\"\r\n    if ds.IsA(\"vtkPolyData\"):\r\n        return PolyData(ds)\r\n    elif ds.IsA(\"vtkUnstructuredGrid\"):\r\n        return UnstructuredGrid(ds)\r\n    elif ds.IsA(\"vtkPointSet\"):\r\n        return PointSet(ds)\r\n    elif ds.IsA(\"vtkDataSet\"):\r\n        return DataSet(ds)\r\n    elif ds.IsA(\"vtkCompositeDataSet\"):\r\n        return CompositeDataSet(ds)\r\n    elif ds.IsA(\"vtkTable\"):\r\n        return Table(ds)\r\n", "meta": {"hexsha": "0ac1f2cf6d646881c59d08aaf238637c7a324939", "size": 42559, "ext": "py", "lang": "Python", "max_stars_repo_path": "VTK/vtk_7.1.1_x64_Release/lib/python2.7/site-packages/vtk/numpy_interface/dataset_adapter.py", "max_stars_repo_name": "jiaguobing/FastCAE", "max_stars_repo_head_hexsha": "2348ab87e83fe5c704e4c998cf391229c25ac5d5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-05-30T01:52:12.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-29T21:12:13.000Z", "max_issues_repo_path": "VTK/vtk_7.1.1_x64_Release/lib/python2.7/site-packages/vtk/numpy_interface/dataset_adapter.py", "max_issues_repo_name": "Sunqia/FastCAE", "max_issues_repo_head_hexsha": "cbc023fe07b6e306ceefae8b8bd7c12bc1562acb", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-03-06T04:49:42.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-06T04:49:42.000Z", "max_forks_repo_path": "VTK/vtk_7.1.1_x64_Release/lib/python2.7/site-packages/vtk/numpy_interface/dataset_adapter.py", "max_forks_repo_name": "Sunqia/FastCAE", "max_forks_repo_head_hexsha": "cbc023fe07b6e306ceefae8b8bd7c12bc1562acb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-08-30T23:36:13.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-08T16:52:01.000Z", "avg_line_length": 39.6266294227, "max_line_length": 109, "alphanum_fraction": 0.6272468808, "include": true, "reason": "import numpy", "num_tokens": 9415, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.11596070756094144, "lm_q1q2_score": 0.055264513546490444}}
{"text": "#!/usr/bin/env python\r\nu\"\"\"\r\nread_cryosat_L2.py\r\nWritten by Tyler Sutterley (10/2018)\r\n\r\nReads CryoSat Level-2 data products from baselines A, B and C\r\nSupported CryoSat Modes: LRM, SAR, SARin, FDM, SID, GDR\r\n\r\nINPUTS:\r\n\tfull_filename: full path of CryoSat .DBL file\r\n\r\nOUTPUTS:\r\n\tData_1Hz: Time and Orbit Parameters\r\n\tCorrections: Elevation Corrections and Flags\r\n\tData_20Hz: Geolocation and Elevation Measurements with Quality Parameters\r\n\tMETADATA: MPH, SPH and DSD Header data\r\n\r\nUPDATE HISTORY:\r\nUpdated 10/2018: updated header read functions for python3\r\nUpdated 11/2016: added Abs_Orbit and Ascending_Flg to Data_1Hz outputs\r\n\tAbs_Orbit should be same as in read_cryosat_ground_tracks.py\r\n\tAscending_Flg can use in surface regression fits following McMillan (2014)\r\nUpdated 05/2016: using __future__ print and division functions\r\nWritten 03/2016\r\n\"\"\"\r\nfrom __future__ import print_function\r\nfrom __future__ import division\r\n\r\nimport os\r\nimport re\r\nimport numpy as np\r\n\r\n#-- PURPOSE: Initiate L2 MDS variables for CryoSat Baselines A and B\r\ndef cryosat_baseline_AB(fid,record_size,n_records):\r\n\t#-- CryoSat-2 1 Hz data fields (Location Group)\r\n\t#-- Time and Orbit Parameters plus Measurement Mode\r\n\tL2_1Hz_parameters = {}\r\n\t#-- Time: day part\r\n\tL2_1Hz_parameters['Day'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Time: second part\r\n\tL2_1Hz_parameters['Second'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Time: microsecond part\r\n\tL2_1Hz_parameters['Micsec'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- SIRAL mode\r\n\tL2_1Hz_parameters['Siral_mode'] = np.zeros((n_records),dtype=np.uint64)\r\n\t#-- Lat_1Hz: packed units (0.1 micro-degree, 1e-7 degrees)\r\n\tL2_1Hz_parameters['Lat_1Hz'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Lon_1Hz: packed units (0.1 micro-degree, 1e-7 degrees)\r\n\tL2_1Hz_parameters['Lon_1Hz'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Alt_1Hz: packed units (mm, 1e-3 m)\r\n\t#-- Altitude of COG above reference ellipsoid (interpolated value)\r\n\tL2_1Hz_parameters['Alt_1Hz'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Mispointing: packed units (millidegrees, 1e-3 degrees)\r\n\tL2_1Hz_parameters['Mispointing'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Number of valid records in the block of twenty that contain data\r\n\t#-- Last few records of the last block of a dataset may be blank blocks\r\n\t#-- inserted to bring the file up to a multiple of twenty.\r\n\tL2_1Hz_parameters['N_valid'] = np.zeros((n_records),dtype=np.int16)\r\n\r\n\t#-- CryoSat-2 geophysical corrections (External Corrections Group)\r\n\tL2_final_corrections = {}\r\n\t#-- Dry Tropospheric Correction packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['dryTrop'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Wet Tropospheric Correction packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['wetTrop'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Inverse Barometric Correction packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['InvBar'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Dynamic Atmosphere Correction packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['DynAtm'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Ionospheric Correction packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['Iono'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Sea State Bias Correction packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['SSB'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Ocean tide Correction packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['ocTideElv'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Long period equilibrium ocean tide Correction packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['lpeTideElv'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Ocean loading tide Correction packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['olTideElv'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Solid Earth tide Correction packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['seTideElv'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Geocentric Polar tide Correction packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['gpTideElv'] = np.zeros((n_records),dtype=np.int16)\r\n\tL2_final_corrections['Spare1'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Surface Type: Packed in groups of three bits for each of the 20 records\r\n\tL2_final_corrections['Surf_type'] = np.zeros((n_records),dtype=np.uint64)\r\n\t#-- Mean Sea Surface or Geoid packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['MSS_Geoid'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Ocean Depth/Land Elevation Model (ODLE) packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['ODLE'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Ice Concentration packed units (%/100)\r\n\tL2_final_corrections['Ice_conc'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Snow Depth packed units (mm, 1e-3 m)\r\n\tL2_final_corrections['Snow_depth'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Snow Density packed units (kg/m^3)\r\n\tL2_final_corrections['Snow_density'] = np.zeros((n_records),dtype=np.int16)\r\n\tL2_final_corrections['Spare2'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Corrections Status Flag\r\n\tL2_final_corrections['C_status'] = np.zeros((n_records),dtype=np.uint32)\r\n\t#-- Significant Wave Height (SWH) packed units (mm, 1e-3)\r\n\tL2_final_corrections['SWH'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Wind Speed packed units (mm/s, 1e-3 m/s)\r\n\tL2_final_corrections['Wind_speed'] = np.zeros((n_records),dtype=np.uint16)\r\n\tL2_final_corrections['Spare3'] = np.zeros((n_records),dtype=np.int16)\r\n\tL2_final_corrections['Spare4'] = np.zeros((n_records),dtype=np.int16)\r\n\tL2_final_corrections['Spare5'] = np.zeros((n_records),dtype=np.int16)\r\n\tL2_final_corrections['Spare6'] = np.zeros((n_records),dtype=np.int16)\r\n\r\n\t#-- CryoSat-2 20 Hz data fields (Measurement Group)\r\n\t#-- Derived from instrument measurement parameters\r\n\tn_blocks = 20\r\n\tL2_final_measurements = {}\r\n\t#-- Delta between the timestamps for 20Hz record and the 1Hz record\r\n\t#-- D_time_mics packed units (microseconds)\r\n\tL2_final_measurements['D_time_mics'] = np.zeros((n_records,n_blocks),dtype=np.int32)\r\n\t#-- Lat: packed units (0.1 micro-degree, 1e-7 degrees)\r\n\tL2_final_measurements['Lat'] = np.zeros((n_records,n_blocks),dtype=np.int32)\r\n\t#-- Lon: packed units (0.1 micro-degree, 1e-7 degrees)\r\n\tL2_final_measurements['Lon'] = np.zeros((n_records,n_blocks),dtype=np.int32)\r\n\t#-- Measured elevation above ellipsoid from retracker: packed units (mm, 1e-3 m)\r\n\tL2_final_measurements['Elev'] = np.zeros((n_records,n_blocks),dtype=np.int32)\r\n\t#-- Interpolated Sea Surface Height Anomaly: packed units (mm, 1e-3 m)\r\n\tL2_final_measurements['SSHA_interp'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Interpolated Sea Surface Height measurement count\r\n\tL2_final_measurements['SSHA_num'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Interpolation quality estimate RSS: packed units (mm, 1e-3 m)\r\n\tL2_final_measurements['SSHA_qual'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Sigma Zero Backscatter for retracker: packed units (1e-2 dB)\r\n\tL2_final_measurements['Sig0'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Peakiness: packed units (1e-2)\r\n\tL2_final_measurements['Peakiness'] = np.zeros((n_records,n_blocks),dtype=np.uint16)\r\n\t#-- Freeboard: packed units (mm, 1e-3 m)\r\n\t#-- -9999 default value indicates computation has not been performed\r\n\tL2_final_measurements['Freeboard'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Number of averaged echoes or beams\r\n\tL2_final_measurements['N_avg'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\tL2_final_measurements['Spare1'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Quality flags\r\n\tL2_final_measurements['Quality_Flg'] = np.zeros((n_records,n_blocks),dtype=np.uint32)\r\n\tL2_final_measurements['Spare2'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\tL2_final_measurements['Spare3'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\tL2_final_measurements['Spare4'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\tL2_final_measurements['Spare5'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- for each record in the CryoSat file\r\n\tfor r in range(n_records):\r\n\t\t#-- CryoSat-2 Location Group for record r\r\n\t\tL2_1Hz_parameters['Day'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_1Hz_parameters['Second'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_1Hz_parameters['Micsec'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_1Hz_parameters['Siral_mode'][r] = np.fromfile(fid,dtype='>u8',count=1)\r\n\t\tL2_1Hz_parameters['Lat_1Hz'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_1Hz_parameters['Lon_1Hz'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_1Hz_parameters['Alt_1Hz'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_1Hz_parameters['Mispointing'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_1Hz_parameters['N_valid'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t#-- CryoSat-2 External Corrections Group for record r\r\n\t\tL2_final_corrections['dryTrop'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['wetTrop'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['InvBar'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['DynAtm'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['Iono'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['SSB'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['ocTideElv'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['lpeTideElv'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['olTideElv'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['seTideElv'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['gpTideElv'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['Spare1'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['Surf_type'][r] = np.fromfile(fid,dtype='>u8',count=1)\r\n\t\tL2_final_corrections['MSS_Geoid'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_final_corrections['ODLE'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_final_corrections['Ice_conc'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['Snow_depth'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['Snow_density'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['Spare2'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['C_status'][r] = np.fromfile(fid,dtype='>u4',count=1)\r\n\t\tL2_final_corrections['SWH'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['Wind_speed'][r] = np.fromfile(fid,dtype='>u2',count=1)\r\n\t\tL2_final_corrections['Spare3'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['Spare4'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['Spare5'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_final_corrections['Spare6'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t#-- CryoSat-2 Measurements Group for record r and block b\r\n\t\tfor b in range(n_blocks):\r\n\t\t\tL2_final_measurements['D_time_mics'][r,b] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\t\tL2_final_measurements['Lat'][r,b] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\t\tL2_final_measurements['Lon'][r,b] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\t\tL2_final_measurements['Elev'][r,b] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\t\tL2_final_measurements['SSHA_interp'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_final_measurements['SSHA_num'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_final_measurements['SSHA_qual'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_final_measurements['Sig0'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_final_measurements['Peakiness'][r,b] = np.fromfile(fid,dtype='>u2',count=1)\r\n\t\t\tL2_final_measurements['Freeboard'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_final_measurements['N_avg'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_final_measurements['Spare1'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_final_measurements['Quality_Flg'][r,b] = np.fromfile(fid,dtype='>u4',count=1)\r\n\t\t\tL2_final_measurements['Spare2'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_final_measurements['Spare3'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_final_measurements['Spare4'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_final_measurements['Spare5'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\r\n\t#-- Bind all the bits of the l2_mds together into a single dictionary\r\n\tCS_l2_mds = {}\r\n\tCS_l2_mds['Data_1Hz'] = L2_1Hz_parameters\r\n\tCS_l2_mds['Corrections'] = L2_final_corrections\r\n\tCS_l2_mds['Data_20Hz'] = L2_final_measurements\r\n\t#-- return the output dictionary\r\n\treturn CS_l2_mds\r\n\r\n#-- PURPOSE: Initiate L2 MDS variables for CryoSat Baseline C\r\ndef cryosat_baseline_C(fid,record_size,n_records):\r\n\t#-- CryoSat-2 1 Hz data fields (Location Group)\r\n\t#-- Time and Orbit Parameters plus Measurement Mode\r\n\tL2_c_1Hz_parameters = {}\r\n\t#-- Time: day part\r\n\tL2_c_1Hz_parameters['Day'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Time: second part\r\n\tL2_c_1Hz_parameters['Second'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Time: microsecond part\r\n\tL2_c_1Hz_parameters['Micsec'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- SIRAL mode\r\n\tL2_c_1Hz_parameters['Siral_mode'] = np.zeros((n_records),dtype=np.uint64)\r\n\t#-- Lat_1Hz: packed units (0.1 micro-degree, 1e-7 degrees)\r\n\tL2_c_1Hz_parameters['Lat_1Hz'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Lon_1Hz: packed units (0.1 micro-degree, 1e-7 degrees)\r\n\tL2_c_1Hz_parameters['Lon_1Hz'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Alt_1Hz: packed units (mm, 1e-3 m)\r\n\t#-- Altitude of COG above reference ellipsoid (interpolated value)\r\n\tL2_c_1Hz_parameters['Alt_1Hz'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Roll: packed units (0.1 micro-degree, 1e-7 degrees)\r\n\tL2_c_1Hz_parameters['Roll'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Pitch: packed units (0.1 micro-degree, 1e-7 degrees)\r\n\tL2_c_1Hz_parameters['Pitch'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Yaw: packed units (0.1 micro-degree, 1e-7 degrees)\r\n\tL2_c_1Hz_parameters['Yaw'] = np.zeros((n_records),dtype=np.int32)\r\n\tL2_c_1Hz_parameters['Spare'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Number of valid records in the block of twenty that contain data\r\n\t#-- Last few records of the last block of a dataset may be blank blocks\r\n\t#-- inserted to bring the file up to a multiple of twenty.\r\n\tL2_c_1Hz_parameters['N_valid'] = np.zeros((n_records),dtype=np.int16)\r\n\r\n\t#-- CryoSat-2 geophysical corrections (External Corrections Group)\r\n\tL2_c_final_corrections = {}\r\n\t#-- Dry Tropospheric Correction packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['dryTrop'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Wet Tropospheric Correction packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['wetTrop'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Inverse Barometric Correction packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['InvBar'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Dynamic Atmosphere Correction packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['DynAtm'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Ionospheric Correction packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['Iono'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Sea State Bias Correction packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['SSB'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Ocean tide Correction packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['ocTideElv'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Long period equilibrium ocean tide Correction packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['lpeTideElv'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Ocean loading tide Correction packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['olTideElv'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Solid Earth tide Correction packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['seTideElv'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Geocentric Polar tide Correction packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['gpTideElv'] = np.zeros((n_records),dtype=np.int16)\r\n\tL2_c_final_corrections['Spare1'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Surface Type: Packed in groups of three bits for each of the 20 records\r\n\tL2_c_final_corrections['Surf_type'] = np.zeros((n_records),dtype=np.uint64)\r\n\t#-- Mean Sea Surface or Geoid packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['MSS_Geoid'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Ocean Depth/Land Elevation Model (ODLE) packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['ODLE'] = np.zeros((n_records),dtype=np.int32)\r\n\t#-- Ice Concentration packed units (%/100)\r\n\tL2_c_final_corrections['Ice_conc'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Snow Depth packed units (mm, 1e-3 m)\r\n\tL2_c_final_corrections['Snow_depth'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Snow Density packed units (kg/m^3)\r\n\tL2_c_final_corrections['Snow_density'] = np.zeros((n_records),dtype=np.int16)\r\n\tL2_c_final_corrections['Spare2'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Corrections Status Flag\r\n\tL2_c_final_corrections['C_status'] = np.zeros((n_records),dtype=np.uint32)\r\n\t#-- Significant Wave Height (SWH) packed units (mm, 1e-3)\r\n\tL2_c_final_corrections['SWH'] = np.zeros((n_records),dtype=np.int16)\r\n\t#-- Wind Speed packed units (mm/s, 1e-3 m/s)\r\n\tL2_c_final_corrections['Wind_speed'] = np.zeros((n_records),dtype=np.uint16)\r\n\tL2_c_final_corrections['Spare3'] = np.zeros((n_records),dtype=np.int16)\r\n\tL2_c_final_corrections['Spare4'] = np.zeros((n_records),dtype=np.int16)\r\n\tL2_c_final_corrections['Spare5'] = np.zeros((n_records),dtype=np.int16)\r\n\tL2_c_final_corrections['Spare6'] = np.zeros((n_records),dtype=np.int16)\r\n\r\n\t#-- CryoSat-2 20 Hz data fields (Measurement Group)\r\n\t#-- Derived from instrument measurement parameters\r\n\tn_blocks = 20\r\n\tL2_c_final_measurements = {}\r\n\t#-- Delta between the timestamps for 20Hz record and the 1Hz record\r\n\t#-- D_time_mics packed units (microseconds)\r\n\tL2_c_final_measurements['D_time_mics'] = np.zeros((n_records,n_blocks),dtype=np.int32)\r\n\t#-- Lat: packed units (0.1 micro-degree, 1e-7 degrees)\r\n\tL2_c_final_measurements['Lat'] = np.zeros((n_records,n_blocks),dtype=np.int32)\r\n\t#-- Lon: packed units (0.1 micro-degree, 1e-7 degrees)\r\n\tL2_c_final_measurements['Lon'] = np.zeros((n_records,n_blocks),dtype=np.int32)\r\n\t#-- Measured elevation above ellipsoid from retracker 1: packed units (mm, 1e-3 m)\r\n\tL2_c_final_measurements['Elev_1'] = np.zeros((n_records,n_blocks),dtype=np.int32)\r\n\t#-- Measured elevation above ellipsoid from retracker 2: packed units (mm, 1e-3 m)\r\n\tL2_c_final_measurements['Elev_2'] = np.zeros((n_records,n_blocks),dtype=np.int32)\r\n\t#-- Measured elevation above ellipsoid from retracker 3: packed units (mm, 1e-3 m)\r\n\tL2_c_final_measurements['Elev_3'] = np.zeros((n_records,n_blocks),dtype=np.int32)\r\n\t#-- Sigma Zero Backscatter for retracker 1: packed units (1e-2 dB)\r\n\tL2_c_final_measurements['Sig0_1'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Sigma Zero Backscatter for retracker 2: packed units (1e-2 dB)\r\n\tL2_c_final_measurements['Sig0_2'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Sigma Zero Backscatter for retracker 3: packed units (1e-2 dB)\r\n\tL2_c_final_measurements['Sig0_3'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Freeboard: packed units (mm, 1e-3 m)\r\n\t#-- -9999 default value indicates computation has not been performed\r\n\tL2_c_final_measurements['Freeboard'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Interpolated Sea Surface Height Anomaly: packed units (mm, 1e-3 m)\r\n\tL2_c_final_measurements['SSHA_interp'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Interpolated Sea Surface Height measurement count\r\n\tL2_c_final_measurements['SSHA_num'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Interpolation quality estimate RSS: packed units (mm, 1e-3 m)\r\n\tL2_c_final_measurements['SSHA_qual'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Peakiness: packed units (1e-2)\r\n\tL2_c_final_measurements['Peakiness'] = np.zeros((n_records,n_blocks),dtype=np.uint16)\r\n\t#-- Number of averaged echoes or beams\r\n\tL2_c_final_measurements['N_avg'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\tL2_c_final_measurements['Spare1'] = np.zeros((n_records,n_blocks),dtype=np.int16)\r\n\t#-- Quality flags\r\n\tL2_c_final_measurements['Quality_Flg'] = np.zeros((n_records,n_blocks),dtype=np.uint32)\r\n\t#-- Corrections Application Flag\r\n\tL2_c_final_measurements['Corrections_Flg'] = np.zeros((n_records,n_blocks),dtype=np.uint32)\r\n\t#-- Quality metric for retracker 1\r\n\tL2_c_final_measurements['Quality_1'] = np.zeros((n_records,n_blocks),dtype=np.int32)\r\n\t#-- Quality metric for retracker 2\r\n\tL2_c_final_measurements['Quality_2'] = np.zeros((n_records,n_blocks),dtype=np.int32)\r\n\t#-- Quality metric for retracker 3\r\n\tL2_c_final_measurements['Quality_3'] = np.zeros((n_records,n_blocks),dtype=np.int32)\r\n\t#-- for each record in the CryoSat file\r\n\tfor r in range(n_records):\r\n\t\t#-- CryoSat-2 Location Group for record r\r\n\t\tL2_c_1Hz_parameters['Day'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_c_1Hz_parameters['Second'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_c_1Hz_parameters['Micsec'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_c_1Hz_parameters['Siral_mode'][r] = np.fromfile(fid,dtype='>u8',count=1)\r\n\t\tL2_c_1Hz_parameters['Lat_1Hz'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_c_1Hz_parameters['Lon_1Hz'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_c_1Hz_parameters['Alt_1Hz'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_c_1Hz_parameters['Roll'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_c_1Hz_parameters['Pitch'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_c_1Hz_parameters['Yaw'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_c_1Hz_parameters['Spare'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_1Hz_parameters['N_valid'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t#-- CryoSat-2 External Corrections Group for record r\r\n\t\tL2_c_final_corrections['dryTrop'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['wetTrop'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['InvBar'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['DynAtm'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['Iono'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['SSB'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['ocTideElv'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['lpeTideElv'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['olTideElv'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['seTideElv'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['gpTideElv'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['Spare1'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['Surf_type'][r] = np.fromfile(fid,dtype='>u8',count=1)\r\n\t\tL2_c_final_corrections['MSS_Geoid'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_c_final_corrections['ODLE'][r] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\tL2_c_final_corrections['Ice_conc'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['Snow_depth'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['Snow_density'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['Spare2'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['C_status'][r] = np.fromfile(fid,dtype='>u4',count=1)\r\n\t\tL2_c_final_corrections['SWH'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['Wind_speed'][r] = np.fromfile(fid,dtype='>u2',count=1)\r\n\t\tL2_c_final_corrections['Spare3'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['Spare4'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['Spare5'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\tL2_c_final_corrections['Spare6'][r] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t#-- CryoSat-2 Measurements Group for record r and block b\r\n\t\tfor b in range(n_blocks):\r\n\t\t\tL2_c_final_measurements['D_time_mics'][r,b] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\t\tL2_c_final_measurements['Lat'][r,b] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\t\tL2_c_final_measurements['Lon'][r,b] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\t\tL2_c_final_measurements['Elev_1'][r,b] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\t\tL2_c_final_measurements['Elev_2'][r,b] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\t\tL2_c_final_measurements['Elev_3'][r,b] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\t\tL2_c_final_measurements['Sig0_1'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_c_final_measurements['Sig0_2'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_c_final_measurements['Sig0_3'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_c_final_measurements['Freeboard'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_c_final_measurements['SSHA_interp'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_c_final_measurements['SSHA_num'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_c_final_measurements['SSHA_qual'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_c_final_measurements['Peakiness'][r,b] = np.fromfile(fid,dtype='>u2',count=1)\r\n\t\t\tL2_c_final_measurements['N_avg'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_c_final_measurements['Spare1'][r,b] = np.fromfile(fid,dtype='>i2',count=1)\r\n\t\t\tL2_c_final_measurements['Quality_Flg'][r,b] = np.fromfile(fid,dtype='>u4',count=1)\r\n\t\t\tL2_c_final_measurements['Corrections_Flg'][r,b] = np.fromfile(fid,dtype='>u4',count=1)\r\n\t\t\tL2_c_final_measurements['Quality_1'][r,b] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\t\tL2_c_final_measurements['Quality_2'][r,b] = np.fromfile(fid,dtype='>i4',count=1)\r\n\t\t\tL2_c_final_measurements['Quality_3'][r,b] = np.fromfile(fid,dtype='>i4',count=1)\r\n\r\n\t#-- Bind all the bits of the l2_mds together into a single dictionary\r\n\tCS_l2_c_mds = {}\r\n\tCS_l2_c_mds['Data_1Hz'] = L2_c_1Hz_parameters\r\n\tCS_l2_c_mds['Corrections'] = L2_c_final_corrections\r\n\tCS_l2_c_mds['Data_20Hz'] = L2_c_final_measurements\r\n\t#-- return the output dictionary\r\n\treturn CS_l2_c_mds\r\n\r\n#-- PURPOSE: Read ASCII Main Product Header (MPH) block from an ESA PDS file\r\ndef read_MPH(full_filename):\r\n\t#-- read input data file\r\n\twith open(full_filename, 'rb') as fid:\r\n\t\tfile_contents = fid.read().splitlines()\r\n\r\n\t#-- Define constant values associated with PDS file formats\r\n\t#-- number of text lines in standard MPH\r\n\tn_MPH_lines\t= 41\r\n\t#-- check that first line of header matches PRODUCT\r\n\tif not bool(re.match(b'PRODUCT\\=\\\"(.*)(?=\\\")',file_contents[0])):\r\n\t\traise IOError('File does not start with a valid PDS MPH')\r\n\t#-- read MPH header text\r\n\ts_MPH_fields = {}\r\n\tfor i in range(n_MPH_lines):\r\n\t\t#-- use regular expression operators to read headers\r\n\t\tif bool(re.match(b'(.*?)\\=\\\"(.*)(?=\\\")',file_contents[i])):\r\n\t\t\t#-- data fields within quotes\r\n\t\t\tfield,value=re.findall(b'(.*?)\\=\\\"(.*)(?=\\\")',file_contents[i]).pop()\r\n\t\t\ts_MPH_fields[field.decode('utf-8')] = value.decode('utf-8').rstrip()\r\n\t\telif bool(re.match(b'(.*?)\\=(.*)',file_contents[i])):\r\n\t\t\t#-- data fields without quotes\r\n\t\t\tfield,value=re.findall(b'(.*?)\\=(.*)',file_contents[i]).pop()\r\n\t\t\ts_MPH_fields[field.decode('utf-8')] = value.decode('utf-8').rstrip()\r\n\r\n\t#-- Return block name array to calling function\r\n\treturn s_MPH_fields\r\n\r\n#-- PURPOSE: Read ASCII Specific Product Header (SPH) block from a PDS file\r\ndef read_SPH(full_filename,j_sph_size):\r\n\t#-- read input data file\r\n\twith open(full_filename, 'rb') as fid:\r\n\t\tfile_contents = fid.read().splitlines()\r\n\r\n\t#-- Define constant values associated with PDS file formats\r\n\t#-- number of text lines in standard MPH\r\n\tn_MPH_lines\t= 41\r\n\t#-- compile regular expression operator for reading headers\r\n\trx = re.compile(b'(.*?)\\=\\\"?(.*)',re.VERBOSE)\r\n\t#-- check first line of header matches SPH_DESCRIPTOR\r\n\tif not bool(re.match(b'SPH\\_DESCRIPTOR\\=',file_contents[n_MPH_lines+1])):\r\n\t\traise IOError('File does not have a valid PDS DSD')\r\n\t#-- read SPH header text (no binary control characters)\r\n\ts_SPH_lines = [li for li in file_contents[n_MPH_lines+1:] if rx.match(li)\r\n\t\tand not re.search(b'[^\\x20-\\x7e]+',li)]\r\n\r\n\t#-- extract SPH header text\r\n\ts_SPH_fields = {}\r\n\tc = 0\r\n\twhile (c < len(s_SPH_lines)):\r\n\t\t#-- check if line is within DS_NAME portion of SPH header\r\n\t\tif bool(re.match(b'DS_NAME',s_SPH_lines[c])):\r\n\t\t\t#-- add dictionary for DS_NAME\r\n\t\t\tfield,value=re.findall(b'(.*?)\\=\\\"(.*)(?=\\\")',s_SPH_lines[c]).pop()\r\n\t\t\tkey = value.decode('utf-8').rstrip()\r\n\t\t\ts_SPH_fields[key] = {}\r\n\t\t\tfor line in s_SPH_lines[c+1:c+7]:\r\n\t\t\t\tif bool(re.match(b'(.*?)\\=\\\"(.*)(?=\\\")',line)):\r\n\t\t\t\t\t#-- data fields within quotes\r\n\t\t\t\t\tdsfield,dsvalue=re.findall(b'(.*?)\\=\\\"(.*)(?=\\\")',line).pop()\r\n\t\t\t\t\ts_SPH_fields[key][dsfield.decode('utf-8')] = dsvalue.decode('utf-8').rstrip()\r\n\t\t\t\telif bool(re.match(b'(.*?)\\=(.*)',line)):\r\n\t\t\t\t\t#-- data fields without quotes\r\n\t\t\t\t\tdsfield,dsvalue=re.findall(b'(.*?)\\=(.*)',line).pop()\r\n\t\t\t\t\ts_SPH_fields[key][dsfield.decode('utf-8')] = dsvalue.decode('utf-8').rstrip()\r\n\t\t\t#-- add 6 to counter to go to next entry\r\n\t\t\tc += 6\r\n\t\t#-- use regular expression operators to read headers\r\n\t\telif bool(re.match(b'(.*?)\\=\\\"(.*)(?=\\\")',s_SPH_lines[c])):\r\n\t\t\t#-- data fields within quotes\r\n\t\t\tfield,value=re.findall(b'(.*?)\\=\\\"(.*)(?=\\\")',s_SPH_lines[c]).pop()\r\n\t\t\ts_SPH_fields[field.decode('utf-8')] = value.decode('utf-8').rstrip()\r\n\t\telif bool(re.match(b'(.*?)\\=(.*)',s_SPH_lines[c])):\r\n\t\t\t#-- data fields without quotes\r\n\t\t\tfield,value=re.findall(b'(.*?)\\=(.*)',s_SPH_lines[c]).pop()\r\n\t\t\ts_SPH_fields[field.decode('utf-8')] = value.decode('utf-8').rstrip()\r\n\t\t#-- add 1 to counter to go to next line\r\n\t\tc += 1\r\n\r\n\t#-- Return block name array to calling function\r\n\treturn s_SPH_fields\r\n\r\n#-- PURPOSE: Read ASCII Data Set Descriptors (DSD) block from a PDS file\r\ndef read_DSD(full_filename):\r\n\t#-- read input data file\r\n\twith open(full_filename, 'rb') as fid:\r\n\t\tfile_contents = fid.read().splitlines()\r\n\r\n\t#-- Define constant values associated with PDS file formats\r\n\t#-- number of text lines in standard MPH\r\n\tn_MPH_lines\t= 41\r\n\t#-- number of text lines in a DSD header\r\n\tn_DSD_lines = 8\r\n\r\n\t#-- Level-2 CryoSat DS_NAMES within files\r\n\tregex_patterns = []\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_LRM_L2[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SAR_L2B[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SAR_L2[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_FDM_L2[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SARIL2B[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SARIL2[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SAR_L2B_I[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SAR_L2A[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SIN_L2[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SID_L2[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_LRMIL2[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_LRM_L2_I[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SARIL2A[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SAR_L2A_I[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SAR_L2_I[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SINIL2[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SIN_L2_I[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SIDIL2[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_SID_L2_I[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_GDR_2A[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_GDR_2B[\\s+]*\"')\r\n\tregex_patterns.append(b'DS_NAME\\=\"SIR_GDR_2[\\s+]*\"')\r\n\t#-- find the DSD starting line within the SPH header\r\n\tc = 0\r\n\tFlag = False\r\n\twhile ((Flag is False) and (c < len(regex_patterns))):\r\n\t\t#-- find indice within\r\n\t\tindice = [i for i,line in enumerate(file_contents[n_MPH_lines+1:]) if\r\n\t\t\tre.search(regex_patterns[c],line)]\r\n\t\tif indice:\r\n\t\t\tFlag = True\r\n\t\telse:\r\n\t\t\tc+=1\r\n\t#-- check that valid indice was found within header\r\n\tif not indice:\r\n\t\traise IOError('Can not find correct DSD field')\r\n\r\n\t#-- extract s_DSD_fields info\r\n\tDSD_START = n_MPH_lines + indice[0] + 1\r\n\ts_DSD_fields = {}\r\n\tfor i in range(DSD_START,DSD_START+n_DSD_lines):\r\n\t\t#-- use regular expression operators to read headers\r\n\t\tif bool(re.match(b'(.*?)\\=\\\"(.*)(?=\\\")',file_contents[i])):\r\n\t\t\t#-- data fields within quotes\r\n\t\t\tfield,value=re.findall(b'(.*?)\\=\\\"(.*)(?=\\\")',file_contents[i]).pop()\r\n\t\t\ts_DSD_fields[field.decode('utf-8')] = value.decode('utf-8').rstrip()\r\n\t\telif bool(re.match(b'(.*?)\\=(.*)',file_contents[i])):\r\n\t\t\t#-- data fields without quotes\r\n\t\t\tfield,value=re.findall(b'(.*?)\\=(.*)',file_contents[i]).pop()\r\n\t\t\ts_DSD_fields[field.decode('utf-8')] = value.decode('utf-8').rstrip()\r\n\r\n\t#-- Return block name array to calling function\r\n\treturn s_DSD_fields\r\n\r\n#-- PURPOSE: read CryoSat Level-2 data\r\ndef read_cryosat_L2(full_filename, VERBOSE=False):\r\n\t#-- file basename and file extension of input file\r\n\tfileBasename,fileExtension=os.path.splitext(os.path.basename(full_filename))\r\n\r\n\t#-- CryoSat file class\r\n\t#-- OFFL (Off Line Processing/Systematic)\r\n\t#-- NRT_ (Near Real Time)\r\n\t#-- RPRO (ReProcessing)\r\n\t#-- TEST (Testing)\r\n\t#-- LTA_ (Long Term Archive)\r\n\tregex_class = 'OFFL|NRT_|RPRO|TEST|LTA_'\r\n\t#-- CryoSat mission products\r\n\t#-- SIR_LRM_2 L2 Product from Low Resolution Mode Processing\r\n\t#-- SIR_FDM_2 L2 Product from Fast Delivery Marine Mode Processing\r\n\t#-- SIR_SIN_2 L2 Product from SAR Interferometric Processing\r\n\t#-- SIR_SID_2 L2 Product from SIN Degraded Processing\r\n\t#-- SIR_SAR_2 L2 Product from SAR Processing\r\n\t#-- SIR_GDR_2 L2 Consolidated Product\r\n\t#-- SIR_LRMI2 In-depth L2 Product from LRM Processing\r\n\t#-- SIR_SINI2 In-depth L2 Product from SIN Processing\r\n\t#-- SIR_SIDI2 In-depth L2 Product from SIN Degraded Process.\r\n\t#-- SIR_SARI2 In-depth L2 Product from SAR Processing\r\n\tregex_products = ('SIR_LRM_2|SIR_FDM_2|SIR_SIN_2|SIR_SID_2|'\r\n\t'SIR_SAR_2|SIR_GDR_2|SIR_LRMI2|SIR_SINI2|SIR_SIDI2|SIR_SARI2')\r\n\t#-- CRYOSAT LEVEL-2 PRODUCTS NAMING RULES\r\n\t#-- Mission Identifier\r\n\t#-- File Class\r\n\t#-- File Product\r\n\t#-- Validity Start Date and Time\r\n\t#-- Validity Stop Date and Time\r\n\t#-- Baseline Identifier\r\n\t#-- Version Number\r\n\tregex_pattern = '(.*?)_({0})_({1})__(\\d+T?\\d+)_(\\d+T?\\d+)_(.*?)(\\d+)'.format(\r\n\t\tregex_class, regex_products)\r\n\trx = re.compile(regex_pattern, re.VERBOSE)\r\n\t#-- extract file information from filename\r\n\tMI,CLASS,PRODUCT,START,STOP,BASELINE,VERSION=rx.findall(fileBasename).pop()\r\n\t#-- Extract Date information\r\n\tstart_yr,start_mon,start_day=np.array([START[:4],START[4:6],START[6:8]],dtype=np.uint16)\r\n\tstart_hh,start_mm,start_ss=np.array([START[-6:-4],START[-4:-2],START[-2:]],dtype=np.uint8)\r\n\tstop_yr,stop_mon,stop_day=np.array([STOP[:4],STOP[4:6],STOP[6:8]],dtype=np.uint16)\r\n\tstop_hh,stop_mm,stop_ss=np.array([STOP[-6:-4],STOP[-4:-2],STOP[-2:]],dtype=np.uint8)\r\n\r\n\t#-- Record sizes\r\n\tCS_L2_MDS_REC_SIZE = 980\r\n\tCS_L2_C_MDS_REC_SIZE = 1392\r\n\t#-- check baseline from file to set i_record_size and allocation function\r\n\tif (BASELINE == 'C'):\r\n\t\ti_record_size = CS_L2_C_MDS_REC_SIZE\r\n\t\tread_cryosat_variables = cryosat_baseline_C\r\n\telse:\r\n\t\ti_record_size = CS_L2_MDS_REC_SIZE\r\n\t\tread_cryosat_variables = cryosat_baseline_AB\r\n\r\n\t#-- read the input file to get file information\r\n\tfid = os.open(os.path.expanduser(full_filename),os.O_RDONLY)\r\n\tfile_info = os.fstat(fid)\r\n\tos.close(fid)\r\n\r\n\t#-- num DSRs from SPH\r\n\tj_num_DSR = np.int32(file_info.st_size//i_record_size)\r\n\t#-- print file information\r\n\tif VERBOSE:\r\n\t\tprint(fileBasename)\r\n\t\tprint('{0:d} {1:d} {2:d}'.format(j_num_DSR,file_info.st_size,i_record_size))\r\n\t\t#-- Check if MPH/SPH/DSD headers\r\n\t\tif (j_num_DSR*i_record_size == file_info.st_size):\r\n\t\t\tprint('No Header on file')\r\n\t\t\tprint('The number of DSRs is: {0:d}'.format(j_num_DSR))\r\n\t\telse:\r\n\t\t\tprint('Header on file')\r\n\r\n\t#-- Check if MPH/SPH/DSD headers\r\n\tif (j_num_DSR*i_record_size != file_info.st_size):\r\n\t\t#-- If there are MPH/SPH/DSD headers\r\n\t\ts_MPH_fields = read_MPH(full_filename)\r\n\t\tj_sph_size = np.int32(re.findall('[-+]?\\d+',s_MPH_fields['SPH_SIZE']).pop())\r\n\t\ts_SPH_fields = read_SPH(full_filename,j_sph_size)\r\n\t\t#-- extract information from DSD fields\r\n\t\ts_DSD_fields = read_DSD(full_filename)\r\n\t\t#-- extract DS_OFFSET\r\n\t\tj_DS_start = np.int32(re.findall('[-+]?\\d+',s_DSD_fields['DS_OFFSET']).pop())\r\n\t\t#-- extract number of DSR in the file\r\n\t\tj_num_DSR = np.int32(re.findall('[-+]?\\d+',s_DSD_fields['NUM_DSR']).pop())\r\n\t\t#-- check the record size\r\n\t\tj_DSR_size = np.int32(re.findall('[-+]?\\d+',s_DSD_fields['DSR_SIZE']).pop())\r\n\t\t#--  minimum size is start of the read plus number of records to read\r\n\t\tj_check_size = j_DS_start +(j_DSR_size*j_num_DSR)\r\n\t\tif VERBOSE:\r\n\t\t\tprint('The offset of the DSD is: {0:d} bytes'.format(j_DS_start))\r\n\t\t\tprint('The number of DSRs is {0:d}'.format(j_num_DSR))\r\n\t\t\tprint('The size of the DSR is {0:d}'.format(j_DSR_size))\r\n\t\t#-- check if invalid file size\r\n\t\tif (j_check_size > file_info.st_size):\r\n\t\t\traise IOError('File size error')\r\n\t\t#-- extract binary data from input CryoSat data file (skip headers)\r\n\t\tfid = open(full_filename, 'rb')\r\n\t\tcryosat_header = fid.read(j_DS_start)\r\n\t\t#-- iterate through CryoSat file and fill output variables\r\n\t\tCS_L2_mds = read_cryosat_variables(fid,i_record_size,j_num_DSR)\r\n\t\t#-- add headers to output dictionary as METADATA\r\n\t\tCS_L2_mds['METADATA'] = {}\r\n\t\tCS_L2_mds['METADATA']['MPH'] = s_MPH_fields\r\n\t\tCS_L2_mds['METADATA']['SPH'] = s_SPH_fields\r\n\t\tCS_L2_mds['METADATA']['DSD'] = s_DSD_fields\r\n\t\t#-- add absolute orbit number to 1Hz data\r\n\t\tCS_L2_mds['Data_1Hz']['Abs_Orbit']=np.zeros((j_num_DSR),dtype=np.uint32)\r\n\t\tCS_L2_mds['Data_1Hz']['Abs_Orbit'][:]=np.uint32(s_MPH_fields['ABS_ORBIT'])\r\n\t\t#-- add ascending/descending flag to 1Hz data (A=ascending,D=descending)\r\n\t\tCS_L2_mds['Data_1Hz']['Ascending_Flg']=np.zeros((j_num_DSR),dtype=np.bool)\r\n\t\tif (s_SPH_fields['ASCENDING_FLAG'] == 'A'):\r\n\t\t\tCS_L2_mds['Data_1Hz']['Ascending_Flg'][:] = True\r\n\t\t#-- close the input CryoSat binary file\r\n\t\tfid.close()\r\n\telse:\r\n\t\t#-- If there are not MPH/SPH/DSD headers\r\n\t\t#-- extract binary data from input CryoSat data file\r\n\t\tfid = open(full_filename, 'rb')\r\n\t\t#-- iterate through CryoSat file and fill output variables\r\n\t\tCS_L2_mds = read_cryosat_variables(fid,i_record_size,j_num_DSR)\r\n\t\t#-- close the input CryoSat binary file\r\n\t\tfid.close()\r\n\r\n\t#-- return the data and headers\r\n\treturn CS_L2_mds\r\n", "meta": {"hexsha": "c0699e70f27a08712282b97f1c28869c3ea3e6ab", "size": 38207, "ext": "py", "lang": "Python", "max_stars_repo_path": "cryosat_toolkit/read_cryosat_L2.py", "max_stars_repo_name": "Sibada/read-cryosat-2", "max_stars_repo_head_hexsha": "3267a0bb52857feb142a67cbb0e352160415c28f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cryosat_toolkit/read_cryosat_L2.py", "max_issues_repo_name": "Sibada/read-cryosat-2", "max_issues_repo_head_hexsha": "3267a0bb52857feb142a67cbb0e352160415c28f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cryosat_toolkit/read_cryosat_L2.py", "max_forks_repo_name": "Sibada/read-cryosat-2", "max_forks_repo_head_hexsha": "3267a0bb52857feb142a67cbb0e352160415c28f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 55.4528301887, "max_line_length": 93, "alphanum_fraction": 0.7101054781, "include": true, "reason": "import numpy", "num_tokens": 12444, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.11124119766818046, "lm_q1q2_score": 0.05518607174613917}}
{"text": "\n# coding: utf-8\n\n# ## Working with Matplotlib\n# Introduction:\n# \n# Matplotlib is a Python 2D plotting library which produces publication quality figures in a variety of hardcopy formats and interactive environments across platforms. Matplotlib can be used in Python scripts, the Python and IPython shell, the jupyter notebook, web application servers, and four graphical user interface toolkits.\n# \n# ### Here are the main steps we will go through\n# * How to save your plot using matplotlib?\n# * How to create plot using matplotlib?\n# * How to make your graph look pretty?\n# \n# This is Just a little illustration.\n# \n# <img style=\"float:left;\" src=\"https://static.lwn.net/images/2015/02-matplotlib-3d.png\"></img>\n\n# #### How to save your plot using matplotlib?\n# I am gonna show you how to save your graph, you can refer the docstring for complete information on the various ways it can be used.\n\n# In[1]:\n\n\n# import matplotlib, numpy\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n\n# In[2]:\n\n\n#saves plot/figure to image\nplt.savefig('name_your_graph.png')\n\n\n# In[11]:\n\n\n# we can create simple plot as follows, linear graph\n# Prepare the data\nlinear = np.linspace(0, 10, 100)\n\n# Plot the data, set label and color, b=blue, g=green\nplt.plot(linear, linear, label='linear', color='b')\n\n# Add a legend\nplt.legend()\n\n# Show the plot\nplt.show()\n\n\n# In[23]:\n\n\n#by calling \nplt.style.available\n\n\n# In[26]:\n\n\nx = np.linspace(0, 4 * np.pi)\ny = np.sin(x)\n\nplt.plot(x, y)\n\nplt.show()\n\n\n# In[27]:\n\n\nplt.style.use('ggplot')\n\nplt.plot(x, y)\n\nplt.show()\n\n\n# In[32]:\n\n\nwith plt.style.context(('seaborn-darkgrid')):\n    plt.plot(x, y, 'r-o')\n    plt.show()\n\n\n# #### Working with text inside your graph\n\n# However, you can use subplots to set up and place your Axes on a regular grid. So that means that in most cases, Axes and subplot are synonymous, they will designate the same thing. When you do call subplot to add Axes to your figure, do so with the add_subplots() function. \n\n# In[14]:\n\n\n# we can create scatter plot for this \nfig = plt.figure()\n\n# Set up Axes\nax = fig.add_subplot(111)\n\n# Scatter the data\nax.scatter(np.linspace(0, 1, 5), np.linspace(0, 5, 5), label='scatter')\n\n# Add a legend\nplt.legend()\n\n# Show the plot\nplt.show()\n\n\n# #### How To Change The Size of Figures\n# \n# Now that you have seen how to initialize a Figure and Axes from scratch, you will also want to know how you can change certain small details that the package sets up for you, such as the figure size.\n# Let’s say you don’t to have your figure size to be default size and you want to change this. How do you set the size of your figures manually?\n\n# In[20]:\n\n\n# easy! you can just call \nfig = plt.figure(figsize=(10,8))\nax1 = fig.add_subplot(121)\nax2 = fig.add_subplot(122)\n\n\n# In[21]:\n\n\n# let's plot simple bar graph\n# Plot the data\nax1.bar([1,2,3],[3,4,5])\nax2.barh([0.5,1,2.5],[0,1,2])\n\n# Show the plot\nplt.show()\n\n\n# In[3]:\n\n\nx = np.linspace(0, 2, 100)\n\nplt.plot(x, x, label='linear')\nplt.plot(x, x**2, label='quadratic')\nplt.plot(x, x**3, label='cubic')\n\nplt.xlabel('x label')\nplt.ylabel('y label')\n\nplt.title(\"Simple Plot\")\n\nplt.legend()\n\nplt.show()\n\n\n# In[4]:\n\n\n#plot data connected by lines\nlines = plt.plot(x,x)\nplt.show()\n\n\n# ## More to come soon!\n", "meta": {"hexsha": "86f1bc504538e05d9d304c35e2294b423d77b744", "size": 3235, "ext": "py", "lang": "Python", "max_stars_repo_path": "All Python Codes/2017-24-11-so-customization-matplotlib.py", "max_stars_repo_name": "bjfisica/MachineLearning", "max_stars_repo_head_hexsha": "20349301ae7f82cd5048410b0cf1f7a5f7d7e5a2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 52, "max_stars_repo_stars_event_min_datetime": "2019-02-15T16:37:13.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-17T18:34:30.000Z", "max_issues_repo_path": "All Python Codes/2017-24-11-so-customization-matplotlib.py", "max_issues_repo_name": "RodeoBlues/Complete-Data-Science-Toolkits", "max_issues_repo_head_hexsha": "c5e83889e24af825ec3baed6e8198debb135f1ff", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "All Python Codes/2017-24-11-so-customization-matplotlib.py", "max_forks_repo_name": "RodeoBlues/Complete-Data-Science-Toolkits", "max_forks_repo_head_hexsha": "c5e83889e24af825ec3baed6e8198debb135f1ff", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 22, "max_forks_repo_forks_event_min_datetime": "2017-11-25T23:42:16.000Z", "max_forks_repo_forks_event_max_datetime": "2019-01-07T09:22:35.000Z", "avg_line_length": 19.4879518072, "max_line_length": 330, "alphanum_fraction": 0.6924265842, "include": true, "reason": "import numpy", "num_tokens": 890, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4148988457967688, "lm_q2_score": 0.13296424363358259, "lm_q1q2_score": 0.05516671121581378}}
{"text": "# Business Objectives/Statistical Questions and Feature Selection\n\n*Hayley Boyce, May 12th, 2021*\n\n**Attribution:** \n\n- Tomas Beuzen - Previous BAIT 509 Lecture 6\n- Varada Kolhatkar - Heavily guiding me with Feature Selection\n\n# Importing our libraries\nimport pandas as pd\nimport altair as alt\nimport numpy as np\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.dummy import DummyClassifier, DummyRegressor\nfrom sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor\nfrom sklearn.model_selection import cross_validate, train_test_split\nfrom sklearn import datasets\nfrom sklearn.linear_model import Ridge\n\nimport sys\nsys.path.append('code/')\nfrom display_tree import display_tree\nfrom plot_classifier import plot_classifier\nimport matplotlib.pyplot as plt\n\n# Preprocessing and pipeline\nfrom sklearn.impute import SimpleImputer\nfrom sklearn.metrics.pairwise import euclidean_distances\nfrom sklearn.pipeline import Pipeline, make_pipeline\nfrom sklearn.compose import make_column_transformer\nfrom sklearn.linear_model import LogisticRegression\n\nfrom sklearn.preprocessing import OneHotEncoder, OrdinalEncoder, StandardScaler, MinMaxScaler\n\nimport scipy\nfrom sklearn.model_selection import RandomizedSearchCV\n\n## House Keeping \n\n- Project instructions are out!\n- Time in class for groups! \n- Assignment 3 was released yesterday!\n- More reading in this lecture than usual (sorry!) \n- Run code at your own risk (Think section can take up to 20 minutes so if you are running this locally, Start running everything NOW from top to bottom)\n\n## Lecture Learning Objectives \n\n- In the context of supervised learning, form statistical questions  from business questions/objectives.\n- Understand the different forms your client may expect you to communicate results. \n- Explain the general concept of feature selection.\n- Discuss and compare different feature selection methods at a high level.\n- Use sklearn's implementation of recursive feature elimination (RFE).\n- Implement the forward search algorithm.\n\n## Five Minute Recap/ Lightning Questions \n\n- What is the name of the function used to bound our values between 0 and 1\n- What is the name of the function that gives \"hard\" predictions?\n- What is the name of the function that gives \"soft\" predictions?\n- What is the hyperparameter we learned for Ridge and how does it affect the Fundamental Trade-off?\n- What is the hyperparameter we learned for Logistic Regression and how does it affect the Fundamental Trade-off?\n\n### Some lingering questions\n\n- How can we start forming good business questions that can be addressed with Machine Learning? \n- How to select features for our models? \n\n## Forming statistical questions to answer business objectives\n\nSo far you've seen how to solve predictive problems using machine learning but today, we are going to look at the process involved in asking the questions and problems faced by organizations. \n\n\nGenerally, there are four parts of a machine learning analysis. In order from high to low level:\n\n1. **The business question/objective**\n2. **The statistical question/objective**\n3. **The data and model**\n4. **The data product**\n\nDoing a machine learning analysis is about distilling from the highest level to the lowest level. As such, there are three distillations to keep in mind: 1-2, 2-3, and 3-4:\n\n- **1-2 is about asking the right questions**\n- **2-3 is about building a useful model**\n- **3-4 is about communicating the results**\n\n<center><img src=\"https://images.unsplash.com/photo-1511225317751-5c2d61819d58?ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&ixlib=rb-1.2.1&auto=format&fit=crop&w=2734&q=80\" width=\"50%\"></center>\n\n     \n     \n    \nNote that an analysis isn’t a linear progression through these “steps”; rather, the process is iterative. This is because none of the components are independent. Making progress on any of the three distillations gives you more information as to what the problem is.\n\nWe’ll look at each of these distillations in turn.\n\n## (1 - 2) Asking useful statistical questions\n\n- Usually, a company is not served up a machine learning problem, complete with data and a description of the response and predictors.\n    - Companies don't exactly know what question is the right question but they do know what they want  to be accomplished. \n- Instead, they’re faced with some high-level objective/question that we’ll call the **business question/objective**.\n- This question needs refining to a **statistical question/objective** – one that is directly addressable by machine learning.\n\nExample: \n\n- My Capstone Case study. \n\n### Business objectives: examples\n- This [altexsoft blog post](https://www.altexsoft.com/blog/business/supervised-learning-use-cases-low-hanging-fruit-in-data-science-for-businesses/) is a great introduction to business use cases of data science/ML\n- Examples of business objectives (for which machine learning is a relevant approach)\n    - Reduce the amount of spam email received\n    - Early prediction of product failure\n    - Find undervalued mines\n    - Make a transit system more efficient\n    - Hire efficient staff\n\n### Refining business objectives to statistical objectives\n\n<img src='https://media.giphy.com/media/bLcMOxvIak4iZieaut/giphy.gif' width=\"50%\"> \n\n- Statistical objectives need to be specific\n- Remember that supervised learning is about predicting a response $Y$ from predictors $X_1,…,X_p$\n- So we need to refine our business objectives to a statistical question(s) we can answer\n- This typically involves:\n    - Identifying the **response variable** ($Y$) that is most aligned with the business objective.\n    - Identifying the **data** (observations + features) that will be used for model development/testing.\n    - Note: part of this is the task of feature selection (a topic that we've covered briefly) – but, this is also largely, a human decision based on what we think is more informative, as well as a resource questions (what data is actually available?)\n\n### Statistical objectives: examples\nStatistical objectives corresponding to the above business objective examples might be:\n\n| Business Objective | Statistical Question |\n| :--- | :--- |\n| Reduce the amount of spam email received | <ul><li>$Y$ = classifying an email as spam/not spam <li> $X$ = words present in name and the body of email and other metadata (sender email, time, etc.) <li> Cases of spam will be gathered over time as employees identify emails as spam/not spam. The model can be improved as misclassifications are encountered.</ul>\n| Early prediction of product failure (Kickstarter?) | <ul><li>$Y$ = classifying a product as faulty/not faulty <li> $X$ = Relevant features chosen by an expert <li> Data obtained from the test facility</ul>\n| Find undervalued mines | <ul><li>$Y$ = total volume of gold and silver at a site <li> $X$ =  concentrations of other minerals found in drill samples, geographic information, historical data, etc <li> Data obtained from mines where total volumes are already known</ul>\n| Make a transit system more efficient | <ul><li>$Y$ = predict the time it takes a bus to travel between set stops <li> $X$ = time of day/week/year, weather, etc. <li> Use data from company server tracking bus movements</ul>\n| Hire efficient staff | <ul><li>$Y$ = predict monthly sales <li> $X$ = a personality test, years of work experience, field of experience, etc. <li> Use data based on current employees</ul>\n\n### Statistical questions are not the full picture!\n- Almost always, the business objective is more complex than the statistical question.\n- By refining a business objective to a statistical one, we may lose part of the essence of the business objective.\n- It’s important to have a sense of the ways in which your statistical objective falls short, and the ways in which it’s on the mark, so that you keep an idea of the big picture.\n- For example, predicting whether a new staff hire will be efficient or not is a useful statistical question, but doesn't consider why a company might be attracting certain applicants, how long staff will remain, how staff work together, etc.\n\n### Statistical objectives unrelated to supervised learning\n\n- We are only focussing on statistical questions related to supervised learning and prediction in this course\n- But there are other kinds of questions you can ask too\n- Consider the following example\n\n**Business objective**: To gain insight into the productivity of two branches of a company.\n\nExamples of statistical questions:\n\n- **Hypothesis testing**: Is the mean number of sick days per employee different between two branches of a company?\n    - Supervised learning doesn’t cover testing for differences.\n- **Unsupervised learning**: What is the mean sentiment of the internal discussion channels from both branches?\n    - There is no data of feature + response here, as required by supervised learning (by definition).\n- **Statistical inference**: Estimate the mean difference in monthly revenue generated by both branches, along with how certain you are with that estimate.\n    - Supervised learning typically isn’t concerned about communicating how certain your estimate is. (BUT it should and progress is occuring to change this!)  \n\n## (2 - 3) Building a useful model\n- This is really the main focus of this course, This is the meat/beyond meat patty in your burger! \n- This involves using ML algorithms (kNN, loess, decision trees, etc) to build a predictive model from data\n- You always should include a baseline model to assess how well the models you build are giving you some leg up. \n- A simple model like logistic regression does as well as more complex approaches! At the very least, they can help guide you on what more complex approaches to take next.\n\n## (3 - 4) Communicating results\n\n- So you've distilled your business objectives to a statistical question.\n- You've developed a model to answer the statistical question.\n- Now your model needs to be delivered and used by others (or your future self)!\n- The final delivery is often called \"the data product\" because it may consist of a variety of things:\n    - a report\n    - a presentation\n    - an app\n    - a dashboard\n    - a software package/pipeline\n- Sometimes the client requests a specific data product -> But note that their suggestion might not always be the best option. \n    - Perhaps they request a report and presentation communicating your findings, when a more appropriate product also includes an interactive app that allows them to explore your findings for themselves.\n- Either way, the key here is communication. Two import challenges (relevant to your final project):\n    - Using appropriate language: there is a lot of jargon in ML, the key is to talk more about the output and the general idea of your model(s), but not machine learning or statistical jargon.\n    - Communication with visual design: this is about choosing what visuals are the most effective for communicating. -> Plug: https://viz-learn.mds.ubc.ca/en/\n- Usually, the first step is to set up a framework for your data product. For a report, this means outlining what you intend to write about, and where.\n- Showing it to your client is useful as a sanity check to see that you’re about to produce something that the client currently sees as being potentially useful.\n\n## Let's Practice \n\n1\\. What question is usually more complex?    \n2\\. What model needs to be made for all problems?     \n3\\. In supervised learning, once we have our business objective, part of our statistical question is identifying what?    \n\n**True or False:**     \n\n4\\. When writing your reports, it's important to consider who is reading it.         \n5\\. Sometimes you may need to dig a little to figure out exactly what the client wants.         \n6\\. In supervised learning, we should take into consideration the uncertainty of our models.         \n\n```{admonition} Solutions!\n:class: dropdown\n\n1. Business question/objective\n2. Baseline - Dummy\n3. Our target variable\n4. True\n5. True\n6. True\n\n```\n\n## Feature Selection \n\n### Motivation \n\nRemember the curse of dimensionality? \n\n<img src='imgs/curse.png' width=\"50%\"> \n\nWe spoke about this briefly when we discussed $k$-nn and how when we add many different dimensions (features) it can confuse the model with any irrelevant features and the model can disintegrate into predictions no better than random guessing.\n\nReasons like this are why we need to be careful about which features we include.\n\n**Feature selection** can be described as *finding the features (columns) $X$ that are important for predicting $y$ and removing the features that aren’t.*\n\nFeature selection can be aided using domain knowledge and manually however we can also use tools that help us either tell us:\n\n- which features are most important to a model \n- or that can select a number of features that will result with the optimal validation score. \n\ncities_df = pd.read_csv(\"data/canada_usa_cities.csv\")\ntrain_df, test_df = train_test_split(cities_df, test_size=0.2, random_state=123)\nX_train, y_train = train_df.drop(columns=[\"country\"], axis=1), train_df[\"country\"]\nX_test, y_test = test_df.drop(columns=[\"country\"], axis=1), test_df[\"country\"]\n\ntrain_df.head()\n\n### Feature importance \n\nRemember our Decision Tree models? Well, we can find out which features are most important in a model using an attribute called `feature_importances_`.\n\ndt_modelku_model = DecisionTreeClassifier(max_depth=5)\ndt_model.fit(X_train, y_train)\ndt_model.feature_importances_\n\nHere we can see that most of the importance is on the column `latitude`. \n\nX_train.columns\n\nIf we graph this, the root of the decision tree will usually reflect the top feature. Just like we can see here:\n\nsys.path.append('code/')\nfrom display_tree import display_tree\ndisplay_tree(X_train.columns, dt_model, \"imgs/decision_tree\")\n\n### New housing data \n\nI know at this point you are probably annoyed and bored of housing data, but good, interesting open-source data is hard to come by. For this example, I really want to show you an example with LOTS of features. \n\nHere is (yet another) housing dataset we acquired from [this GitHub repo](https://github.com/melindaleung/Ames-Iowa-Housing-Dataset), originally created by Dean De Cock. \n*(We are using the raw data so we do not need to store it and import it simply from the url.)*\n\n\n**Attribution:** \n\nThe Ames Housing dataset was compiled by Dean De Cock for use in data science education. \n\nHis publication can be found [here](http://jse.amstat.org/v19n3/decock.pdf).\n\names_df = pd.read_csv('https://raw.githubusercontent.com/melindaleung/Ames-Iowa-Housing-Dataset/master/data/ames%20iowa%20housing.csv', index_col=0)\names_df.loc[ames_df['SaleCondition'] != 'Normal', 'SaleCondition'] = 'Abnormal'\names_df\n\names_df.info()\n\nHere, we use `.info()` to identify our categorical and numeric features. I split my features and identify my target. \n\nThe target variable for this question is `SaleCondition` and we are doing classification.\n\ntrain_df, test_df = train_test_split(ames_df, test_size=0.2, random_state=77)\n\nX_train = train_df.drop(columns=['SaleCondition', 'PoolQC', 'MiscFeature', 'Alley'])\nX_test =  test_df.drop(columns=['SaleCondition', 'PoolQC', 'MiscFeature', 'Alley'])\n\ny_train = train_df['SaleCondition']\ny_test = test_df['SaleCondition']\n\n Note, you should be looking at these individually but I'm being a little lazy here. \n\nnumeric_features = X_train.select_dtypes('number').columns.to_list()\ncategorical_features = X_train.select_dtypes('object').columns.to_list()\n\nHere are our numeric features:\n\nnumeric_features\n\nAnd here are our categorical features:\n\ncategorical_features\n\nNext, we need to make our pipelines and column transformer. \n\nWe can also cross-validate, but here my main goal is to show you how to get our feature importances from our pipeline! \n\nnumeric_pipe = make_pipeline(SimpleImputer(strategy='median'),\n                            StandardScaler())\ncategoric_pipe = make_pipeline(SimpleImputer(strategy=\"constant\", fill_value=\"missing\"),\n                            OneHotEncoder(dtype=int, handle_unknown=\"ignore\"))\n\npreprocessor = make_column_transformer((numeric_pipe, numeric_features),\n                                       (categoric_pipe, categorical_features))\n\nmain_pipe = make_pipeline(preprocessor, LogisticRegression(max_iter=1000))\n\n\nscores = cross_validate(main_pipe, X_train, y_train, return_train_score=True)\n\npd.DataFrame(scores).mean()\n\nOnce we fit our pipeline outside of `cross_validate()` we can use `coef_` to get our features that contribute to our predictions. \n\nmain_pipe.fit(X_train, y_train)\nfeats_coef = main_pipe.named_steps['logisticregression'].coef_\nfeats_coef\n\nThe problem here, is we don't know which value corresponds to which feature! \n\nLet's first take a look at how many features we have now after preprocessing. \n\nfeats_coef.shape\n\nThe 282 is refering to the number of features after preprocessing!\n\nLet's get the feature names after preprocessing.  \n\nWe can obtain the categorical features and combine them with the  numeric features.\n\ncat_feats = preprocessor.named_transformers_['pipeline-2'].named_steps[\n    'onehotencoder'].get_feature_names(categorical_features).tolist()\n\nall_feat_names = numeric_features + cat_feats\n\nWe can see now that we have the same number of feature names as we do coefficients. \n\nlen(all_feat_names)\n\nLet's get them into a dataframe now and sort them:\n\nfeatures_df = pd.DataFrame(data = [all_feat_names,\n                                feats_coef.flatten()]).T.rename(columns={0:'feature', 1:'feature_coefs'})\nfeatures_df.sort_values('feature_coefs',key= abs, ascending=False)\n\n\nWe can see that `SaleType_New` is the most important feature in our model.\n\nFrom here we can decide to manually remove some of the columns that are not taken into consideration as much.... or we can instead use a tool to help us! \n\nEnter - **Recursive feature elimination**\n\n### Recursive feature elimination - RFE \n\nWe can use feature importances to eliminate unimportant features.\n\nThe basic idea with recursive feature elimination is we: \n1. We decide $k$ - the number of features to select.\n2. Assign importances to features, e.g. by fitting a model and looking at coef_ or feature_importances_.\n3. Remove the least important feature.\n4. Repeat steps 2-3 until only $k$ features are remaining.\n\n**Note that this is not the same as just removing all the less important features in one shot!**\n\nLet's take a look at how we can do this. \n\nFirst we import `RFE` from `sklearn.feature_selection`: \n\nfrom sklearn.feature_selection import RFE\n\nNow instead of simply using `LogisticRegression`, we can wrap it around the `RFE` function and specify how many features we want with `n_features_to_select`. \n\nHere I'm capping the number of features to 30 (an arbitrary number I picked).\n\nThis is going to take about 1-2 minutes to run because now, it's recursively removing 1 feature at a time and cross-validating on the final result.\n\n\n<img src='imgs/waiting2.png' width=\"50%\"> \n\nmain_pipe = make_pipeline(preprocessor, RFE(LogisticRegression(max_iter=1000), \n                                            n_features_to_select=30))\n\nscores = cross_validate(main_pipe, X_train, y_train, return_train_score=True)\n\npd.DataFrame(scores)\n\npd.DataFrame(scores).mean()\n\nLooking at this mean validation score compared to when the model was using all the features, we can see it increased a tiny bit! \n\nBut now our next question is how do we set $k$? How do we know how many features is the optimal amount... Well, you guessed it! There is a tool for that too! \n\n### RFECV\n\nYou can find the optimal number of features using cross-validation with `RFECV` where the optimal $k$ value is selected based on the highest validation score. \n\nYou would definitely not want to use the training score! - Why?\n > Because with training score the more features you add the higher the score, this isn't the case with validation score. \n \nWe can import `RFECV` from `sklearn.feature_selection` like we did for `RFE`. \n\nfrom sklearn.feature_selection import RFECV\n\nInstead of `RFE` now we simply use `RFECV` in our pipeline and we do not need to specify the argument `n_features_to_select` like we did with `RFE` since $k$ is selected based on the highest validation score. \n\n(*This is also going to take a couple of minutes*)\n\n<img src='imgs/waiting1.png' width=\"50%\"> \n\n\n\nmain_pipe = make_pipeline(preprocessor, RFECV(LogisticRegression(max_iter=1000), cv=5))\n\nscores = cross_validate(main_pipe, X_train, y_train, return_train_score=True)\n\nNow we have ~91% for our validation score! \n\npd.DataFrame(scores).mean()\n\nmain_pipe.fit(X_train,y_train)\nprint(main_pipe.named_steps[\"rfecv\"].support_)\n\nprint(\"The number of features selected by RFE: \",\n      main_pipe.named_steps[\"rfecv\"].n_features_)\n\nfeature_names = all_feat_names\nsupport = main_pipe.named_steps[\"rfecv\"].support_\nRFE_selected_feats = np.array(feature_names)[support]\nRFE_selected_feats\n\nRFECV selects the features by references their `feature_importances`/`coefs_` as well as the validation score after each feature is removed and seeing if it is increasing. \n\nWhen a feature is removed and the validation score is no longer increasing, then it stops removing features. \n\n## Forward Selection \n\nUnlike with RFE where we start with all our features and gradually remove the leat important ones, **Forward Selection** is a process where we start with no features and gradually add them! \n\nWith RFE we removed the least important feature, whereas with forward selection we add features untill our cross-validation score starts to decreases. \n\nForward Selection does not guaranty finding the best features set but reduces many problems.\nComputationally cheaper (aka faster!) \nOverfits less\n\n\nForward selection is recently implemented in `sklearn` so please make sure it is up to date! You need version 0.24!\n\nfrom sklearn.feature_selection import SequentialFeatureSelector\n\nWe can import it as follows: \n\npipe_forward = make_pipeline(preprocessor, \n                             SequentialFeatureSelector(LogisticRegression(max_iter=1000), \n                                                       direction='forward',\n                                                       n_features_to_select=20),\n                            LogisticRegression(max_iter=1000))\n\nRunning this next cell is going to take a LONG LONG LONG time. \n\n<img src='imgs/waiting3.png' width=\"50%\"> \n\nscores = cross_validate(pipe_forward, X_train, y_train, \n                        return_train_score=True)\npd.DataFrame(scores).mean()\n\n## Let's Practice \n\n1\\. As we increase features, which score will always increase?    \n2\\. Between `RFE` and `RFECV` which one finds the optimal number of features for us?    \n3\\. Which method starts with all our features and iteratively removes them from our model?    \n4\\. Which method starts with no features and iteratively adds features?    \n5\\. Which method does not take into consideration `feature_importances_`/`coefs_` when adding/removing features?     \n\n```{admonition} Solutions!\n:class: dropdown\n\n1. Training score\n2. `RFECV`\n3. Recursive Feature Elimination\n4. Forward Selection\n5. Forward Selection\n```\n\n## Extra time? Project time\n\nFirst -> Project expectations. \n\nBreakout rooms in your project groups! \n\nUse this time to:\n\n- Meet with your team mates;\n- Think about a project - choose the data and business objective.\n- Propose a statistical objective to address this.\n- Also, elaborate on the statistical objective. What’s your plan for the analysis?\n\n## What We've Learned Today\n\n- How to construct a statistical question from a business objective. \n- What steps are important in building your analysis.\n- How to discover important features in your model. \n- the 2 different methods (RFE, Forward selection) to conduct feature selection on your model. ", "meta": {"hexsha": "3b12c848cb6edef78bab9ae052710aa4e69f54aa", "size": 23829, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/lectures/lecture8.py", "max_stars_repo_name": "hfboyce/tableau_course", "max_stars_repo_head_hexsha": "1480600c711bfa91d2169e999bbf194dd0332088", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_build/jupyter_execute/lectures/lecture8.py", "max_issues_repo_name": "hfboyce/tableau_course", "max_issues_repo_head_hexsha": "1480600c711bfa91d2169e999bbf194dd0332088", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/lectures/lecture8.py", "max_forks_repo_name": "hfboyce/tableau_course", "max_forks_repo_head_hexsha": "1480600c711bfa91d2169e999bbf194dd0332088", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.907480315, "max_line_length": 360, "alphanum_fraction": 0.7641529229, "include": true, "reason": "import numpy,import scipy", "num_tokens": 5242, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4882833952958347, "lm_q2_score": 0.1127954077740912, "lm_q1q2_score": 0.055076124681711434}}
{"text": "\"\"\"\nThis module provides convenient functions to transform sympy expressions to\nlambda functions which can be used to calculate numerical values very fast.\n\"\"\"\n\nfrom typing import Any, Dict, Iterable\n\nimport builtins\nimport inspect\nimport keyword\nimport textwrap\nimport linecache\n\nfrom sympy.core.basic import Basic\nfrom sympy.utilities.exceptions import SymPyDeprecationWarning\nfrom sympy.core.compatibility import (is_sequence, iterable,\n    NotIterable)\nfrom sympy.utilities.misc import filldedent\nfrom sympy.utilities.decorator import doctest_depends_on\n\n__doctest_requires__ = {('lambdify',): ['numpy', 'tensorflow']}\n\n# Default namespaces, letting us define translations that can't be defined\n# by simple variable maps, like I => 1j\nMATH_DEFAULT = {}  # type: Dict[str, Any]\nMPMATH_DEFAULT = {}  # type: Dict[str, Any]\nNUMPY_DEFAULT = {\"I\": 1j}  # type: Dict[str, Any]\nSCIPY_DEFAULT = {\"I\": 1j}  # type: Dict[str, Any]\nCUPY_DEFAULT = {\"I\": 1j}  # type: Dict[str, Any]\nTENSORFLOW_DEFAULT = {}  # type: Dict[str, Any]\nSYMPY_DEFAULT = {}  # type: Dict[str, Any]\nNUMEXPR_DEFAULT = {}  # type: Dict[str, Any]\n\n# These are the namespaces the lambda functions will use.\n# These are separate from the names above because they are modified\n# throughout this file, whereas the defaults should remain unmodified.\n\nMATH = MATH_DEFAULT.copy()\nMPMATH = MPMATH_DEFAULT.copy()\nNUMPY = NUMPY_DEFAULT.copy()\nSCIPY = SCIPY_DEFAULT.copy()\nCUPY = CUPY_DEFAULT.copy()\nTENSORFLOW = TENSORFLOW_DEFAULT.copy()\nSYMPY = SYMPY_DEFAULT.copy()\nNUMEXPR = NUMEXPR_DEFAULT.copy()\n\n\n# Mappings between sympy and other modules function names.\nMATH_TRANSLATIONS = {\n    \"ceiling\": \"ceil\",\n    \"E\": \"e\",\n    \"ln\": \"log\",\n}\n\n# NOTE: This dictionary is reused in Function._eval_evalf to allow subclasses\n# of Function to automatically evalf.\nMPMATH_TRANSLATIONS = {\n    \"Abs\": \"fabs\",\n    \"elliptic_k\": \"ellipk\",\n    \"elliptic_f\": \"ellipf\",\n    \"elliptic_e\": \"ellipe\",\n    \"elliptic_pi\": \"ellippi\",\n    \"ceiling\": \"ceil\",\n    \"chebyshevt\": \"chebyt\",\n    \"chebyshevu\": \"chebyu\",\n    \"E\": \"e\",\n    \"I\": \"j\",\n    \"ln\": \"log\",\n    #\"lowergamma\":\"lower_gamma\",\n    \"oo\": \"inf\",\n    #\"uppergamma\":\"upper_gamma\",\n    \"LambertW\": \"lambertw\",\n    \"MutableDenseMatrix\": \"matrix\",\n    \"ImmutableDenseMatrix\": \"matrix\",\n    \"conjugate\": \"conj\",\n    \"dirichlet_eta\": \"altzeta\",\n    \"Ei\": \"ei\",\n    \"Shi\": \"shi\",\n    \"Chi\": \"chi\",\n    \"Si\": \"si\",\n    \"Ci\": \"ci\",\n    \"RisingFactorial\": \"rf\",\n    \"FallingFactorial\": \"ff\",\n    \"betainc_regularized\": \"betainc\",\n}\n\nNUMPY_TRANSLATIONS = {\n    \"Heaviside\": \"heaviside\",\n    }  # type: Dict[str, str]\nSCIPY_TRANSLATIONS = {}  # type: Dict[str, str]\nCUPY_TRANSLATIONS = {}  # type: Dict[str, str]\n\nTENSORFLOW_TRANSLATIONS = {}  # type: Dict[str, str]\n\nNUMEXPR_TRANSLATIONS = {}  # type: Dict[str, str]\n\n# Available modules:\nMODULES = {\n    \"math\": (MATH, MATH_DEFAULT, MATH_TRANSLATIONS, (\"from math import *\",)),\n    \"mpmath\": (MPMATH, MPMATH_DEFAULT, MPMATH_TRANSLATIONS, (\"from mpmath import *\",)),\n    \"numpy\": (NUMPY, NUMPY_DEFAULT, NUMPY_TRANSLATIONS, (\"import numpy; from numpy import *; from numpy.linalg import *\",)),\n    \"scipy\": (SCIPY, SCIPY_DEFAULT, SCIPY_TRANSLATIONS, (\"import numpy; import scipy; from scipy import *; from scipy.special import *\",)),\n    \"cupy\": (CUPY, CUPY_DEFAULT, CUPY_TRANSLATIONS, (\"import cupy\",)),\n    \"tensorflow\": (TENSORFLOW, TENSORFLOW_DEFAULT, TENSORFLOW_TRANSLATIONS, (\"import tensorflow\",)),\n    \"sympy\": (SYMPY, SYMPY_DEFAULT, {}, (\n        \"from sympy.functions import *\",\n        \"from sympy.matrices import *\",\n        \"from sympy import Integral, pi, oo, nan, zoo, E, I\",)),\n    \"numexpr\" : (NUMEXPR, NUMEXPR_DEFAULT, NUMEXPR_TRANSLATIONS,\n                 (\"import_module('numexpr')\", )),\n}\n\n\ndef _import(module, reload=False):\n    \"\"\"\n    Creates a global translation dictionary for module.\n\n    The argument module has to be one of the following strings: \"math\",\n    \"mpmath\", \"numpy\", \"sympy\", \"tensorflow\".\n    These dictionaries map names of python functions to their equivalent in\n    other modules.\n    \"\"\"\n    # Required despite static analysis claiming it is not used\n    from sympy.external import import_module # noqa:F401\n    try:\n        namespace, namespace_default, translations, import_commands = MODULES[\n            module]\n    except KeyError:\n        raise NameError(\n            \"'%s' module cannot be used for lambdification\" % module)\n\n    # Clear namespace or exit\n    if namespace != namespace_default:\n        # The namespace was already generated, don't do it again if not forced.\n        if reload:\n            namespace.clear()\n            namespace.update(namespace_default)\n        else:\n            return\n\n    for import_command in import_commands:\n        if import_command.startswith('import_module'):\n            module = eval(import_command)\n\n            if module is not None:\n                namespace.update(module.__dict__)\n                continue\n        else:\n            try:\n                exec(import_command, {}, namespace)\n                continue\n            except ImportError:\n                pass\n\n        raise ImportError(\n            \"Cannot import '%s' with '%s' command\" % (module, import_command))\n\n    # Add translated names to namespace\n    for sympyname, translation in translations.items():\n        namespace[sympyname] = namespace[translation]\n\n    # For computing the modulus of a sympy expression we use the builtin abs\n    # function, instead of the previously used fabs function for all\n    # translation modules. This is because the fabs function in the math\n    # module does not accept complex valued arguments. (see issue 9474). The\n    # only exception, where we don't use the builtin abs function is the\n    # mpmath translation module, because mpmath.fabs returns mpf objects in\n    # contrast to abs().\n    if 'Abs' not in namespace:\n        namespace['Abs'] = abs\n\n\n# Used for dynamically generated filenames that are inserted into the\n# linecache.\n_lambdify_generated_counter = 1\n\n@doctest_depends_on(modules=('numpy', 'scipy', 'tensorflow',), python_version=(3,))\ndef lambdify(args: Iterable, expr, modules=None, printer=None, use_imps=True,\n             dummify=False, cse=False):\n    \"\"\"Convert a SymPy expression into a function that allows for fast\n    numeric evaluation.\n\n    .. warning::\n       This function uses ``exec``, and thus shouldn't be used on\n       unsanitized input.\n\n    .. versionchanged:: 1.7.0\n       Passing a set for the *args* parameter is deprecated as sets are\n       unordered. Use an ordered iterable such as a list or tuple.\n\n    Explanation\n    ===========\n\n    For example, to convert the SymPy expression ``sin(x) + cos(x)`` to an\n    equivalent NumPy function that numerically evaluates it:\n\n    >>> from sympy import sin, cos, symbols, lambdify\n    >>> import numpy as np\n    >>> x = symbols('x')\n    >>> expr = sin(x) + cos(x)\n    >>> expr\n    sin(x) + cos(x)\n    >>> f = lambdify(x, expr, 'numpy')\n    >>> a = np.array([1, 2])\n    >>> f(a)\n    [1.38177329 0.49315059]\n\n    The primary purpose of this function is to provide a bridge from SymPy\n    expressions to numerical libraries such as NumPy, SciPy, NumExpr, mpmath,\n    and tensorflow. In general, SymPy functions do not work with objects from\n    other libraries, such as NumPy arrays, and functions from numeric\n    libraries like NumPy or mpmath do not work on SymPy expressions.\n    ``lambdify`` bridges the two by converting a SymPy expression to an\n    equivalent numeric function.\n\n    The basic workflow with ``lambdify`` is to first create a SymPy expression\n    representing whatever mathematical function you wish to evaluate. This\n    should be done using only SymPy functions and expressions. Then, use\n    ``lambdify`` to convert this to an equivalent function for numerical\n    evaluation. For instance, above we created ``expr`` using the SymPy symbol\n    ``x`` and SymPy functions ``sin`` and ``cos``, then converted it to an\n    equivalent NumPy function ``f``, and called it on a NumPy array ``a``.\n\n    Parameters\n    ==========\n\n    args : List[Symbol]\n        A variable or a list of variables whose nesting represents the\n        nesting of the arguments that will be passed to the function.\n\n        Variables can be symbols, undefined functions, or matrix symbols.\n\n        >>> from sympy import Eq\n        >>> from sympy.abc import x, y, z\n\n        The list of variables should match the structure of how the\n        arguments will be passed to the function. Simply enclose the\n        parameters as they will be passed in a list.\n\n        To call a function like ``f(x)`` then ``[x]``\n        should be the first argument to ``lambdify``; for this\n        case a single ``x`` can also be used:\n\n        >>> f = lambdify(x, x + 1)\n        >>> f(1)\n        2\n        >>> f = lambdify([x], x + 1)\n        >>> f(1)\n        2\n\n        To call a function like ``f(x, y)`` then ``[x, y]`` will\n        be the first argument of the ``lambdify``:\n\n        >>> f = lambdify([x, y], x + y)\n        >>> f(1, 1)\n        2\n\n        To call a function with a single 3-element tuple like\n        ``f((x, y, z))`` then ``[(x, y, z)]`` will be the first\n        argument of the ``lambdify``:\n\n        >>> f = lambdify([(x, y, z)], Eq(z**2, x**2 + y**2))\n        >>> f((3, 4, 5))\n        True\n\n        If two args will be passed and the first is a scalar but\n        the second is a tuple with two arguments then the items\n        in the list should match that structure:\n\n        >>> f = lambdify([x, (y, z)], x + y + z)\n        >>> f(1, (2, 3))\n        6\n\n    expr : Expr\n        An expression, list of expressions, or matrix to be evaluated.\n\n        Lists may be nested.\n        If the expression is a list, the output will also be a list.\n\n        >>> f = lambdify(x, [x, [x + 1, x + 2]])\n        >>> f(1)\n        [1, [2, 3]]\n\n        If it is a matrix, an array will be returned (for the NumPy module).\n\n        >>> from sympy import Matrix\n        >>> f = lambdify(x, Matrix([x, x + 1]))\n        >>> f(1)\n        [[1]\n        [2]]\n\n        Note that the argument order here (variables then expression) is used\n        to emulate the Python ``lambda`` keyword. ``lambdify(x, expr)`` works\n        (roughly) like ``lambda x: expr``\n        (see :ref:`lambdify-how-it-works` below).\n\n    modules : str, optional\n        Specifies the numeric library to use.\n\n        If not specified, *modules* defaults to:\n\n        - ``[\"scipy\", \"numpy\"]`` if SciPy is installed\n        - ``[\"numpy\"]`` if only NumPy is installed\n        - ``[\"math\", \"mpmath\", \"sympy\"]`` if neither is installed.\n\n        That is, SymPy functions are replaced as far as possible by\n        either ``scipy`` or ``numpy`` functions if available, and Python's\n        standard library ``math``, or ``mpmath`` functions otherwise.\n\n        *modules* can be one of the following types:\n\n        - The strings ``\"math\"``, ``\"mpmath\"``, ``\"numpy\"``, ``\"numexpr\"``,\n          ``\"scipy\"``, ``\"sympy\"``, or ``\"tensorflow\"``. This uses the\n          corresponding printer and namespace mapping for that module.\n        - A module (e.g., ``math``). This uses the global namespace of the\n          module. If the module is one of the above known modules, it will\n          also use the corresponding printer and namespace mapping\n          (i.e., ``modules=numpy`` is equivalent to ``modules=\"numpy\"``).\n        - A dictionary that maps names of SymPy functions to arbitrary\n          functions\n          (e.g., ``{'sin': custom_sin}``).\n        - A list that contains a mix of the arguments above, with higher\n          priority given to entries appearing first\n          (e.g., to use the NumPy module but override the ``sin`` function\n          with a custom version, you can use\n          ``[{'sin': custom_sin}, 'numpy']``).\n\n    dummify : bool, optional\n        Whether or not the variables in the provided expression that are not\n        valid Python identifiers are substituted with dummy symbols.\n\n        This allows for undefined functions like ``Function('f')(t)`` to be\n        supplied as arguments. By default, the variables are only dummified\n        if they are not valid Python identifiers.\n\n        Set ``dummify=True`` to replace all arguments with dummy symbols\n        (if ``args`` is not a string) - for example, to ensure that the\n        arguments do not redefine any built-in names.\n\n    cse : bool, or callable, optional\n        Large expressions can be computed more efficiently when\n        common subexpressions are identified and precomputed before\n        being used multiple time. Finding the subexpressions will make\n        creation of the 'lambdify' function slower, however.\n\n        When ``True``, ``sympy.simplify.cse`` is used, otherwise (the default)\n        the user may pass a function matching the ``cse`` signature.\n\n\n    Examples\n    ========\n\n    >>> from sympy.utilities.lambdify import implemented_function\n    >>> from sympy import sqrt, sin, Matrix\n    >>> from sympy import Function\n    >>> from sympy.abc import w, x, y, z\n\n    >>> f = lambdify(x, x**2)\n    >>> f(2)\n    4\n    >>> f = lambdify((x, y, z), [z, y, x])\n    >>> f(1,2,3)\n    [3, 2, 1]\n    >>> f = lambdify(x, sqrt(x))\n    >>> f(4)\n    2.0\n    >>> f = lambdify((x, y), sin(x*y)**2)\n    >>> f(0, 5)\n    0.0\n    >>> row = lambdify((x, y), Matrix((x, x + y)).T, modules='sympy')\n    >>> row(1, 2)\n    Matrix([[1, 3]])\n\n    ``lambdify`` can be used to translate SymPy expressions into mpmath\n    functions. This may be preferable to using ``evalf`` (which uses mpmath on\n    the backend) in some cases.\n\n    >>> f = lambdify(x, sin(x), 'mpmath')\n    >>> f(1)\n    0.8414709848078965\n\n    Tuple arguments are handled and the lambdified function should\n    be called with the same type of arguments as were used to create\n    the function:\n\n    >>> f = lambdify((x, (y, z)), x + y)\n    >>> f(1, (2, 4))\n    3\n\n    The ``flatten`` function can be used to always work with flattened\n    arguments:\n\n    >>> from sympy.utilities.iterables import flatten\n    >>> args = w, (x, (y, z))\n    >>> vals = 1, (2, (3, 4))\n    >>> f = lambdify(flatten(args), w + x + y + z)\n    >>> f(*flatten(vals))\n    10\n\n    Functions present in ``expr`` can also carry their own numerical\n    implementations, in a callable attached to the ``_imp_`` attribute. This\n    can be used with undefined functions using the ``implemented_function``\n    factory:\n\n    >>> f = implemented_function(Function('f'), lambda x: x+1)\n    >>> func = lambdify(x, f(x))\n    >>> func(4)\n    5\n\n    ``lambdify`` always prefers ``_imp_`` implementations to implementations\n    in other namespaces, unless the ``use_imps`` input parameter is False.\n\n    Usage with Tensorflow:\n\n    >>> import tensorflow as tf\n    >>> from sympy import Max, sin, lambdify\n    >>> from sympy.abc import x\n\n    >>> f = Max(x, sin(x))\n    >>> func = lambdify(x, f, 'tensorflow')\n\n    After tensorflow v2, eager execution is enabled by default.\n    If you want to get the compatible result across tensorflow v1 and v2\n    as same as this tutorial, run this line.\n\n    >>> tf.compat.v1.enable_eager_execution()\n\n    If you have eager execution enabled, you can get the result out\n    immediately as you can use numpy.\n\n    If you pass tensorflow objects, you may get an ``EagerTensor``\n    object instead of value.\n\n    >>> result = func(tf.constant(1.0))\n    >>> print(result)\n    tf.Tensor(1.0, shape=(), dtype=float32)\n    >>> print(result.__class__)\n    <class 'tensorflow.python.framework.ops.EagerTensor'>\n\n    You can use ``.numpy()`` to get the numpy value of the tensor.\n\n    >>> result.numpy()\n    1.0\n\n    >>> var = tf.Variable(2.0)\n    >>> result = func(var) # also works for tf.Variable and tf.Placeholder\n    >>> result.numpy()\n    2.0\n\n    And it works with any shape array.\n\n    >>> tensor = tf.constant([[1.0, 2.0], [3.0, 4.0]])\n    >>> result = func(tensor)\n    >>> result.numpy()\n    [[1. 2.]\n     [3. 4.]]\n\n    Notes\n    =====\n\n    - For functions involving large array calculations, numexpr can provide a\n      significant speedup over numpy. Please note that the available functions\n      for numexpr are more limited than numpy but can be expanded with\n      ``implemented_function`` and user defined subclasses of Function. If\n      specified, numexpr may be the only option in modules. The official list\n      of numexpr functions can be found at:\n      https://numexpr.readthedocs.io/en/latest/user_guide.html#supported-functions\n\n    - In previous versions of SymPy, ``lambdify`` replaced ``Matrix`` with\n      ``numpy.matrix`` by default. As of SymPy 1.0 ``numpy.array`` is the\n      default. To get the old default behavior you must pass in\n      ``[{'ImmutableDenseMatrix':  numpy.matrix}, 'numpy']`` to the\n      ``modules`` kwarg.\n\n      >>> from sympy import lambdify, Matrix\n      >>> from sympy.abc import x, y\n      >>> import numpy\n      >>> array2mat = [{'ImmutableDenseMatrix': numpy.matrix}, 'numpy']\n      >>> f = lambdify((x, y), Matrix([x, y]), modules=array2mat)\n      >>> f(1, 2)\n      [[1]\n       [2]]\n\n    - In the above examples, the generated functions can accept scalar\n      values or numpy arrays as arguments.  However, in some cases\n      the generated function relies on the input being a numpy array:\n\n      >>> from sympy import Piecewise\n      >>> from sympy.testing.pytest import ignore_warnings\n      >>> f = lambdify(x, Piecewise((x, x <= 1), (1/x, x > 1)), \"numpy\")\n\n      >>> with ignore_warnings(RuntimeWarning):\n      ...     f(numpy.array([-1, 0, 1, 2]))\n      [-1.   0.   1.   0.5]\n\n      >>> f(0)\n      Traceback (most recent call last):\n          ...\n      ZeroDivisionError: division by zero\n\n      In such cases, the input should be wrapped in a numpy array:\n\n      >>> with ignore_warnings(RuntimeWarning):\n      ...     float(f(numpy.array([0])))\n      0.0\n\n      Or if numpy functionality is not required another module can be used:\n\n      >>> f = lambdify(x, Piecewise((x, x <= 1), (1/x, x > 1)), \"math\")\n      >>> f(0)\n      0\n\n    .. _lambdify-how-it-works:\n\n    How it works\n    ============\n\n    When using this function, it helps a great deal to have an idea of what it\n    is doing. At its core, lambdify is nothing more than a namespace\n    translation, on top of a special printer that makes some corner cases work\n    properly.\n\n    To understand lambdify, first we must properly understand how Python\n    namespaces work. Say we had two files. One called ``sin_cos_sympy.py``,\n    with\n\n    .. code:: python\n\n        # sin_cos_sympy.py\n\n        from sympy import sin, cos\n\n        def sin_cos(x):\n            return sin(x) + cos(x)\n\n\n    and one called ``sin_cos_numpy.py`` with\n\n    .. code:: python\n\n        # sin_cos_numpy.py\n\n        from numpy import sin, cos\n\n        def sin_cos(x):\n            return sin(x) + cos(x)\n\n    The two files define an identical function ``sin_cos``. However, in the\n    first file, ``sin`` and ``cos`` are defined as the SymPy ``sin`` and\n    ``cos``. In the second, they are defined as the NumPy versions.\n\n    If we were to import the first file and use the ``sin_cos`` function, we\n    would get something like\n\n    >>> from sin_cos_sympy import sin_cos # doctest: +SKIP\n    >>> sin_cos(1) # doctest: +SKIP\n    cos(1) + sin(1)\n\n    On the other hand, if we imported ``sin_cos`` from the second file, we\n    would get\n\n    >>> from sin_cos_numpy import sin_cos # doctest: +SKIP\n    >>> sin_cos(1) # doctest: +SKIP\n    1.38177329068\n\n    In the first case we got a symbolic output, because it used the symbolic\n    ``sin`` and ``cos`` functions from SymPy. In the second, we got a numeric\n    result, because ``sin_cos`` used the numeric ``sin`` and ``cos`` functions\n    from NumPy. But notice that the versions of ``sin`` and ``cos`` that were\n    used was not inherent to the ``sin_cos`` function definition. Both\n    ``sin_cos`` definitions are exactly the same. Rather, it was based on the\n    names defined at the module where the ``sin_cos`` function was defined.\n\n    The key point here is that when function in Python references a name that\n    is not defined in the function, that name is looked up in the \"global\"\n    namespace of the module where that function is defined.\n\n    Now, in Python, we can emulate this behavior without actually writing a\n    file to disk using the ``exec`` function. ``exec`` takes a string\n    containing a block of Python code, and a dictionary that should contain\n    the global variables of the module. It then executes the code \"in\" that\n    dictionary, as if it were the module globals. The following is equivalent\n    to the ``sin_cos`` defined in ``sin_cos_sympy.py``:\n\n    >>> import sympy\n    >>> module_dictionary = {'sin': sympy.sin, 'cos': sympy.cos}\n    >>> exec('''\n    ... def sin_cos(x):\n    ...     return sin(x) + cos(x)\n    ... ''', module_dictionary)\n    >>> sin_cos = module_dictionary['sin_cos']\n    >>> sin_cos(1)\n    cos(1) + sin(1)\n\n    and similarly with ``sin_cos_numpy``:\n\n    >>> import numpy\n    >>> module_dictionary = {'sin': numpy.sin, 'cos': numpy.cos}\n    >>> exec('''\n    ... def sin_cos(x):\n    ...     return sin(x) + cos(x)\n    ... ''', module_dictionary)\n    >>> sin_cos = module_dictionary['sin_cos']\n    >>> sin_cos(1)\n    1.38177329068\n\n    So now we can get an idea of how ``lambdify`` works. The name \"lambdify\"\n    comes from the fact that we can think of something like ``lambdify(x,\n    sin(x) + cos(x), 'numpy')`` as ``lambda x: sin(x) + cos(x)``, where\n    ``sin`` and ``cos`` come from the ``numpy`` namespace. This is also why\n    the symbols argument is first in ``lambdify``, as opposed to most SymPy\n    functions where it comes after the expression: to better mimic the\n    ``lambda`` keyword.\n\n    ``lambdify`` takes the input expression (like ``sin(x) + cos(x)``) and\n\n    1. Converts it to a string\n    2. Creates a module globals dictionary based on the modules that are\n       passed in (by default, it uses the NumPy module)\n    3. Creates the string ``\"def func({vars}): return {expr}\"``, where ``{vars}`` is the\n       list of variables separated by commas, and ``{expr}`` is the string\n       created in step 1., then ``exec``s that string with the module globals\n       namespace and returns ``func``.\n\n    In fact, functions returned by ``lambdify`` support inspection. So you can\n    see exactly how they are defined by using ``inspect.getsource``, or ``??`` if you\n    are using IPython or the Jupyter notebook.\n\n    >>> f = lambdify(x, sin(x) + cos(x))\n    >>> import inspect\n    >>> print(inspect.getsource(f))\n    def _lambdifygenerated(x):\n        return sin(x) + cos(x)\n\n    This shows us the source code of the function, but not the namespace it\n    was defined in. We can inspect that by looking at the ``__globals__``\n    attribute of ``f``:\n\n    >>> f.__globals__['sin']\n    <ufunc 'sin'>\n    >>> f.__globals__['cos']\n    <ufunc 'cos'>\n    >>> f.__globals__['sin'] is numpy.sin\n    True\n\n    This shows us that ``sin`` and ``cos`` in the namespace of ``f`` will be\n    ``numpy.sin`` and ``numpy.cos``.\n\n    Note that there are some convenience layers in each of these steps, but at\n    the core, this is how ``lambdify`` works. Step 1 is done using the\n    ``LambdaPrinter`` printers defined in the printing module (see\n    :mod:`sympy.printing.lambdarepr`). This allows different SymPy expressions\n    to define how they should be converted to a string for different modules.\n    You can change which printer ``lambdify`` uses by passing a custom printer\n    in to the ``printer`` argument.\n\n    Step 2 is augmented by certain translations. There are default\n    translations for each module, but you can provide your own by passing a\n    list to the ``modules`` argument. For instance,\n\n    >>> def mysin(x):\n    ...     print('taking the sin of', x)\n    ...     return numpy.sin(x)\n    ...\n    >>> f = lambdify(x, sin(x), [{'sin': mysin}, 'numpy'])\n    >>> f(1)\n    taking the sin of 1\n    0.8414709848078965\n\n    The globals dictionary is generated from the list by merging the\n    dictionary ``{'sin': mysin}`` and the module dictionary for NumPy. The\n    merging is done so that earlier items take precedence, which is why\n    ``mysin`` is used above instead of ``numpy.sin``.\n\n    If you want to modify the way ``lambdify`` works for a given function, it\n    is usually easiest to do so by modifying the globals dictionary as such.\n    In more complicated cases, it may be necessary to create and pass in a\n    custom printer.\n\n    Finally, step 3 is augmented with certain convenience operations, such as\n    the addition of a docstring.\n\n    Understanding how ``lambdify`` works can make it easier to avoid certain\n    gotchas when using it. For instance, a common mistake is to create a\n    lambdified function for one module (say, NumPy), and pass it objects from\n    another (say, a SymPy expression).\n\n    For instance, say we create\n\n    >>> from sympy.abc import x\n    >>> f = lambdify(x, x + 1, 'numpy')\n\n    Now if we pass in a NumPy array, we get that array plus 1\n\n    >>> import numpy\n    >>> a = numpy.array([1, 2])\n    >>> f(a)\n    [2 3]\n\n    But what happens if you make the mistake of passing in a SymPy expression\n    instead of a NumPy array:\n\n    >>> f(x + 1)\n    x + 2\n\n    This worked, but it was only by accident. Now take a different lambdified\n    function:\n\n    >>> from sympy import sin\n    >>> g = lambdify(x, x + sin(x), 'numpy')\n\n    This works as expected on NumPy arrays:\n\n    >>> g(a)\n    [1.84147098 2.90929743]\n\n    But if we try to pass in a SymPy expression, it fails\n\n    >>> try:\n    ...     g(x + 1)\n    ... # NumPy release after 1.17 raises TypeError instead of\n    ... # AttributeError\n    ... except (AttributeError, TypeError):\n    ...     raise AttributeError() # doctest: +IGNORE_EXCEPTION_DETAIL\n    Traceback (most recent call last):\n    ...\n    AttributeError:\n\n    Now, let's look at what happened. The reason this fails is that ``g``\n    calls ``numpy.sin`` on the input expression, and ``numpy.sin`` does not\n    know how to operate on a SymPy object. **As a general rule, NumPy\n    functions do not know how to operate on SymPy expressions, and SymPy\n    functions do not know how to operate on NumPy arrays. This is why lambdify\n    exists: to provide a bridge between SymPy and NumPy.**\n\n    However, why is it that ``f`` did work? That's because ``f`` doesn't call\n    any functions, it only adds 1. So the resulting function that is created,\n    ``def _lambdifygenerated(x): return x + 1`` does not depend on the globals\n    namespace it is defined in. Thus it works, but only by accident. A future\n    version of ``lambdify`` may remove this behavior.\n\n    Be aware that certain implementation details described here may change in\n    future versions of SymPy. The API of passing in custom modules and\n    printers will not change, but the details of how a lambda function is\n    created may change. However, the basic idea will remain the same, and\n    understanding it will be helpful to understanding the behavior of\n    lambdify.\n\n    **In general: you should create lambdified functions for one module (say,\n    NumPy), and only pass it input types that are compatible with that module\n    (say, NumPy arrays).** Remember that by default, if the ``module``\n    argument is not provided, ``lambdify`` creates functions using the NumPy\n    and SciPy namespaces.\n    \"\"\"\n    from sympy.core.symbol import Symbol\n\n    # If the user hasn't specified any modules, use what is available.\n    if modules is None:\n        try:\n            _import(\"scipy\")\n        except ImportError:\n            try:\n                _import(\"numpy\")\n            except ImportError:\n                # Use either numpy (if available) or python.math where possible.\n                # XXX: This leads to different behaviour on different systems and\n                #      might be the reason for irreproducible errors.\n                modules = [\"math\", \"mpmath\", \"sympy\"]\n            else:\n                modules = [\"numpy\"]\n        else:\n            modules = [\"numpy\", \"scipy\"]\n\n    # Get the needed namespaces.\n    namespaces = []\n    # First find any function implementations\n    if use_imps:\n        namespaces.append(_imp_namespace(expr))\n    # Check for dict before iterating\n    if isinstance(modules, (dict, str)) or not hasattr(modules, '__iter__'):\n        namespaces.append(modules)\n    else:\n        # consistency check\n        if _module_present('numexpr', modules) and len(modules) > 1:\n            raise TypeError(\"numexpr must be the only item in 'modules'\")\n        namespaces += list(modules)\n    # fill namespace with first having highest priority\n    namespace = {} # type: Dict[str, Any]\n    for m in namespaces[::-1]:\n        buf = _get_namespace(m)\n        namespace.update(buf)\n\n    if hasattr(expr, \"atoms\"):\n        #Try if you can extract symbols from the expression.\n        #Move on if expr.atoms in not implemented.\n        syms = expr.atoms(Symbol)\n        for term in syms:\n            namespace.update({str(term): term})\n\n    if printer is None:\n        if _module_present('mpmath', namespaces):\n            from sympy.printing.pycode import MpmathPrinter as Printer # type: ignore\n        elif _module_present('scipy', namespaces):\n            from sympy.printing.numpy import SciPyPrinter as Printer # type: ignore\n        elif _module_present('numpy', namespaces):\n            from sympy.printing.numpy import NumPyPrinter as Printer # type: ignore\n        elif _module_present('cupy', namespaces):\n            from sympy.printing.numpy import CuPyPrinter as Printer # type: ignore\n        elif _module_present('numexpr', namespaces):\n            from sympy.printing.lambdarepr import NumExprPrinter as Printer # type: ignore\n        elif _module_present('tensorflow', namespaces):\n            from sympy.printing.tensorflow import TensorflowPrinter as Printer # type: ignore\n        elif _module_present('sympy', namespaces):\n            from sympy.printing.pycode import SymPyPrinter as Printer # type: ignore\n        else:\n            from sympy.printing.pycode import PythonCodePrinter as Printer # type: ignore\n        user_functions = {}\n        for m in namespaces[::-1]:\n            if isinstance(m, dict):\n                for k in m:\n                    user_functions[k] = k\n        printer = Printer({'fully_qualified_modules': False, 'inline': True,\n                           'allow_unknown_functions': True,\n                           'user_functions': user_functions})\n\n    if isinstance(args, set):\n        SymPyDeprecationWarning(\n                    feature=\"The list of arguments is a `set`. This leads to unpredictable results\",\n                    useinstead=\": Convert set into list or tuple\",\n                    issue=20013,\n                    deprecated_since_version=\"1.6.3\"\n                ).warn()\n\n    # Get the names of the args, for creating a docstring\n    if not iterable(args):\n        args = (args,)\n    names = []\n\n    # Grab the callers frame, for getting the names by inspection (if needed)\n    callers_local_vars = inspect.currentframe().f_back.f_locals.items() # type: ignore\n    for n, var in enumerate(args):\n        if hasattr(var, 'name'):\n            names.append(var.name)\n        else:\n            # It's an iterable. Try to get name by inspection of calling frame.\n            name_list = [var_name for var_name, var_val in callers_local_vars\n                    if var_val is var]\n            if len(name_list) == 1:\n                names.append(name_list[0])\n            else:\n                # Cannot infer name with certainty. arg_# will have to do.\n                names.append('arg_' + str(n))\n\n    # Create the function definition code and execute it\n    funcname = '_lambdifygenerated'\n    if _module_present('tensorflow', namespaces):\n        funcprinter = _TensorflowEvaluatorPrinter(printer, dummify) # type: _EvaluatorPrinter\n    else:\n        funcprinter = _EvaluatorPrinter(printer, dummify)\n\n    if cse == True:\n        from sympy.simplify.cse_main import cse\n        cses, _expr = cse(expr, list=False)\n    elif callable(cse):\n        cses, _expr = cse(expr)\n    else:\n        cses, _expr = (), expr\n    funcstr = funcprinter.doprint(funcname, args, _expr, cses=cses)\n\n    # Collect the module imports from the code printers.\n    imp_mod_lines = []\n    for mod, keys in (getattr(printer, 'module_imports', None) or {}).items():\n        for k in keys:\n            if k not in namespace:\n                ln = \"from %s import %s\" % (mod, k)\n                try:\n                    exec(ln, {}, namespace)\n                except ImportError:\n                    # Tensorflow 2.0 has issues with importing a specific\n                    # function from its submodule.\n                    # https://github.com/tensorflow/tensorflow/issues/33022\n                    ln = \"%s = %s.%s\" % (k, mod, k)\n                    exec(ln, {}, namespace)\n                imp_mod_lines.append(ln)\n\n    # Provide lambda expression with builtins, and compatible implementation of range\n    namespace.update({'builtins':builtins, 'range':range})\n\n    funclocals = {} # type: Dict[str, Any]\n    global _lambdify_generated_counter\n    filename = '<lambdifygenerated-%s>' % _lambdify_generated_counter\n    _lambdify_generated_counter += 1\n    c = compile(funcstr, filename, 'exec')\n    exec(c, namespace, funclocals)\n    # mtime has to be None or else linecache.checkcache will remove it\n    linecache.cache[filename] = (len(funcstr), None, funcstr.splitlines(True), filename) # type: ignore\n\n    func = funclocals[funcname]\n\n    # Apply the docstring\n    sig = \"func({})\".format(\", \".join(str(i) for i in names))\n    sig = textwrap.fill(sig, subsequent_indent=' '*8)\n    expr_str = str(expr)\n    if len(expr_str) > 78:\n        expr_str = textwrap.wrap(expr_str, 75)[0] + '...'\n    func.__doc__ = (\n        \"Created with lambdify. Signature:\\n\\n\"\n        \"{sig}\\n\\n\"\n        \"Expression:\\n\\n\"\n        \"{expr}\\n\\n\"\n        \"Source code:\\n\\n\"\n        \"{src}\\n\\n\"\n        \"Imported modules:\\n\\n\"\n        \"{imp_mods}\"\n        ).format(sig=sig, expr=expr_str, src=funcstr, imp_mods='\\n'.join(imp_mod_lines))\n    return func\n\ndef _module_present(modname, modlist):\n    if modname in modlist:\n        return True\n    for m in modlist:\n        if hasattr(m, '__name__') and m.__name__ == modname:\n            return True\n    return False\n\ndef _get_namespace(m):\n    \"\"\"\n    This is used by _lambdify to parse its arguments.\n    \"\"\"\n    if isinstance(m, str):\n        _import(m)\n        return MODULES[m][0]\n    elif isinstance(m, dict):\n        return m\n    elif hasattr(m, \"__dict__\"):\n        return m.__dict__\n    else:\n        raise TypeError(\"Argument must be either a string, dict or module but it is: %s\" % m)\n\n\ndef _recursive_to_string(doprint, arg):\n    \"\"\"Functions in lambdify accept both sympy types and non-sympy types such as python\n    lists and tuples. This method ensures that we only call the doprint method of the\n    printer with SymPy types (so that the printer safely can use SymPy-methods).\"\"\"\n    from sympy.matrices.common import MatrixOperations\n\n    if isinstance(arg, (Basic, MatrixOperations)):\n        return doprint(arg)\n    elif iterable(arg):\n        if isinstance(arg, list):\n            left, right = \"[]\"\n        elif isinstance(arg, tuple):\n            left, right = \"()\"\n        else:\n            raise NotImplementedError(\"unhandled type: %s, %s\" % (type(arg), arg))\n        return left +', '.join(_recursive_to_string(doprint, e) for e in arg) + right\n    elif isinstance(arg, str):\n        return arg\n    else:\n        return doprint(arg)\n\n\ndef lambdastr(args, expr, printer=None, dummify=None):\n    \"\"\"\n    Returns a string that can be evaluated to a lambda function.\n\n    Examples\n    ========\n\n    >>> from sympy.abc import x, y, z\n    >>> from sympy.utilities.lambdify import lambdastr\n    >>> lambdastr(x, x**2)\n    'lambda x: (x**2)'\n    >>> lambdastr((x,y,z), [z,y,x])\n    'lambda x,y,z: ([z, y, x])'\n\n    Although tuples may not appear as arguments to lambda in Python 3,\n    lambdastr will create a lambda function that will unpack the original\n    arguments so that nested arguments can be handled:\n\n    >>> lambdastr((x, (y, z)), x + y)\n    'lambda _0,_1: (lambda x,y,z: (x + y))(_0,_1[0],_1[1])'\n    \"\"\"\n    # Transforming everything to strings.\n    from sympy.matrices import DeferredVector\n    from sympy import Dummy, sympify, Symbol, Function, flatten, Derivative\n\n    if printer is not None:\n        if inspect.isfunction(printer):\n            lambdarepr = printer\n        else:\n            if inspect.isclass(printer):\n                lambdarepr = lambda expr: printer().doprint(expr)\n            else:\n                lambdarepr = lambda expr: printer.doprint(expr)\n    else:\n        #XXX: This has to be done here because of circular imports\n        from sympy.printing.lambdarepr import lambdarepr\n\n    def sub_args(args, dummies_dict):\n        if isinstance(args, str):\n            return args\n        elif isinstance(args, DeferredVector):\n            return str(args)\n        elif iterable(args):\n            dummies = flatten([sub_args(a, dummies_dict) for a in args])\n            return \",\".join(str(a) for a in dummies)\n        else:\n            # replace these with Dummy symbols\n            if isinstance(args, (Function, Symbol, Derivative)):\n                dummies = Dummy()\n                dummies_dict.update({args : dummies})\n                return str(dummies)\n            else:\n                return str(args)\n\n    def sub_expr(expr, dummies_dict):\n        expr = sympify(expr)\n        # dict/tuple are sympified to Basic\n        if isinstance(expr, Basic):\n            expr = expr.xreplace(dummies_dict)\n        # list is not sympified to Basic\n        elif isinstance(expr, list):\n            expr = [sub_expr(a, dummies_dict) for a in expr]\n        return expr\n\n    # Transform args\n    def isiter(l):\n        return iterable(l, exclude=(str, DeferredVector, NotIterable))\n\n    def flat_indexes(iterable):\n        n = 0\n\n        for el in iterable:\n            if isiter(el):\n                for ndeep in flat_indexes(el):\n                    yield (n,) + ndeep\n            else:\n                yield (n,)\n\n            n += 1\n\n    if dummify is None:\n        dummify = any(isinstance(a, Basic) and\n            a.atoms(Function, Derivative) for a in (\n            args if isiter(args) else [args]))\n\n    if isiter(args) and any(isiter(i) for i in args):\n        dum_args = [str(Dummy(str(i))) for i in range(len(args))]\n\n        indexed_args = ','.join([\n            dum_args[ind[0]] + ''.join([\"[%s]\" % k for k in ind[1:]])\n                    for ind in flat_indexes(args)])\n\n        lstr = lambdastr(flatten(args), expr, printer=printer, dummify=dummify)\n\n        return 'lambda %s: (%s)(%s)' % (','.join(dum_args), lstr, indexed_args)\n\n    dummies_dict = {}\n    if dummify:\n        args = sub_args(args, dummies_dict)\n    else:\n        if isinstance(args, str):\n            pass\n        elif iterable(args, exclude=DeferredVector):\n            args = \",\".join(str(a) for a in args)\n\n    # Transform expr\n    if dummify:\n        if isinstance(expr, str):\n            pass\n        else:\n            expr = sub_expr(expr, dummies_dict)\n    expr = _recursive_to_string(lambdarepr, expr)\n    return \"lambda %s: (%s)\" % (args, expr)\n\nclass _EvaluatorPrinter:\n    def __init__(self, printer=None, dummify=False):\n        self._dummify = dummify\n\n        #XXX: This has to be done here because of circular imports\n        from sympy.printing.lambdarepr import LambdaPrinter\n\n        if printer is None:\n            printer = LambdaPrinter()\n\n        if inspect.isfunction(printer):\n            self._exprrepr = printer\n        else:\n            if inspect.isclass(printer):\n                printer = printer()\n\n            self._exprrepr = printer.doprint\n\n            #if hasattr(printer, '_print_Symbol'):\n            #    symbolrepr = printer._print_Symbol\n\n            #if hasattr(printer, '_print_Dummy'):\n            #    dummyrepr = printer._print_Dummy\n\n        # Used to print the generated function arguments in a standard way\n        self._argrepr = LambdaPrinter().doprint\n\n    def doprint(self, funcname, args, expr, *, cses=()):\n        \"\"\"\n        Returns the function definition code as a string.\n        \"\"\"\n        from sympy import Dummy\n\n        funcbody = []\n\n        if not iterable(args):\n            args = [args]\n\n        argstrs, expr = self._preprocess(args, expr)\n\n        # Generate argument unpacking and final argument list\n        funcargs = []\n        unpackings = []\n\n        for argstr in argstrs:\n            if iterable(argstr):\n                funcargs.append(self._argrepr(Dummy()))\n                unpackings.extend(self._print_unpacking(argstr, funcargs[-1]))\n            else:\n                funcargs.append(argstr)\n\n        funcsig = 'def {}({}):'.format(funcname, ', '.join(funcargs))\n\n        # Wrap input arguments before unpacking\n        funcbody.extend(self._print_funcargwrapping(funcargs))\n\n        funcbody.extend(unpackings)\n\n        for s, e in cses:\n            if e is None:\n                funcbody.append('del {}'.format(s))\n            else:\n                funcbody.append('{} = {}'.format(s, self._exprrepr(e)))\n\n        str_expr = _recursive_to_string(self._exprrepr, expr)\n\n\n        if '\\n' in str_expr:\n            str_expr = '({})'.format(str_expr)\n        funcbody.append('return {}'.format(str_expr))\n\n        funclines = [funcsig]\n        funclines.extend(['    ' + line for line in funcbody])\n\n        return '\\n'.join(funclines) + '\\n'\n\n    @classmethod\n    def _is_safe_ident(cls, ident):\n        return isinstance(ident, str) and ident.isidentifier() \\\n                and not keyword.iskeyword(ident)\n\n    def _preprocess(self, args, expr):\n        \"\"\"Preprocess args, expr to replace arguments that do not map\n        to valid Python identifiers.\n\n        Returns string form of args, and updated expr.\n        \"\"\"\n        from sympy import Dummy, Function, flatten, Derivative, ordered, Basic\n        from sympy.matrices import DeferredVector\n        from sympy.core.symbol import uniquely_named_symbol\n        from sympy.core.expr import Expr\n\n        # Args of type Dummy can cause name collisions with args\n        # of type Symbol.  Force dummify of everything in this\n        # situation.\n        dummify = self._dummify or any(\n            isinstance(arg, Dummy) for arg in flatten(args))\n\n        argstrs = [None]*len(args)\n        for arg, i in reversed(list(ordered(zip(args, range(len(args)))))):\n            if iterable(arg):\n                s, expr = self._preprocess(arg, expr)\n            elif isinstance(arg, DeferredVector):\n                s = str(arg)\n            elif isinstance(arg, Basic) and arg.is_symbol:\n                s = self._argrepr(arg)\n                if dummify or not self._is_safe_ident(s):\n                    dummy = Dummy()\n                    if isinstance(expr, Expr):\n                        dummy = uniquely_named_symbol(\n                            dummy.name, expr, modify=lambda s: '_' + s)\n                    s = self._argrepr(dummy)\n                    expr = self._subexpr(expr, {arg: dummy})\n            elif dummify or isinstance(arg, (Function, Derivative)):\n                dummy = Dummy()\n                s = self._argrepr(dummy)\n                expr = self._subexpr(expr, {arg: dummy})\n            else:\n                s = str(arg)\n            argstrs[i] = s\n        return argstrs, expr\n\n    def _subexpr(self, expr, dummies_dict):\n        from sympy.matrices import DeferredVector\n        from sympy import sympify\n\n        expr = sympify(expr)\n        xreplace = getattr(expr, 'xreplace', None)\n        if xreplace is not None:\n            expr = xreplace(dummies_dict)\n        else:\n            if isinstance(expr, DeferredVector):\n                pass\n            elif isinstance(expr, dict):\n                k = [self._subexpr(sympify(a), dummies_dict) for a in expr.keys()]\n                v = [self._subexpr(sympify(a), dummies_dict) for a in expr.values()]\n                expr = dict(zip(k, v))\n            elif isinstance(expr, tuple):\n                expr = tuple(self._subexpr(sympify(a), dummies_dict) for a in expr)\n            elif isinstance(expr, list):\n                expr = [self._subexpr(sympify(a), dummies_dict) for a in expr]\n        return expr\n\n    def _print_funcargwrapping(self, args):\n        \"\"\"Generate argument wrapping code.\n\n        args is the argument list of the generated function (strings).\n\n        Return value is a list of lines of code that will be inserted  at\n        the beginning of the function definition.\n        \"\"\"\n        return []\n\n    def _print_unpacking(self, unpackto, arg):\n        \"\"\"Generate argument unpacking code.\n\n        arg is the function argument to be unpacked (a string), and\n        unpackto is a list or nested lists of the variable names (strings) to\n        unpack to.\n        \"\"\"\n        def unpack_lhs(lvalues):\n            return '[{}]'.format(', '.join(\n                unpack_lhs(val) if iterable(val) else val for val in lvalues))\n\n        return ['{} = {}'.format(unpack_lhs(unpackto), arg)]\n\nclass _TensorflowEvaluatorPrinter(_EvaluatorPrinter):\n    def _print_unpacking(self, lvalues, rvalue):\n        \"\"\"Generate argument unpacking code.\n\n        This method is used when the input value is not interable,\n        but can be indexed (see issue #14655).\n        \"\"\"\n        from sympy import flatten\n\n        def flat_indexes(elems):\n            n = 0\n\n            for el in elems:\n                if iterable(el):\n                    for ndeep in flat_indexes(el):\n                        yield (n,) + ndeep\n                else:\n                    yield (n,)\n\n                n += 1\n\n        indexed = ', '.join('{}[{}]'.format(rvalue, ']['.join(map(str, ind)))\n                                for ind in flat_indexes(lvalues))\n\n        return ['[{}] = [{}]'.format(', '.join(flatten(lvalues)), indexed)]\n\ndef _imp_namespace(expr, namespace=None):\n    \"\"\" Return namespace dict with function implementations\n\n    We need to search for functions in anything that can be thrown at\n    us - that is - anything that could be passed as ``expr``.  Examples\n    include sympy expressions, as well as tuples, lists and dicts that may\n    contain sympy expressions.\n\n    Parameters\n    ----------\n    expr : object\n       Something passed to lambdify, that will generate valid code from\n       ``str(expr)``.\n    namespace : None or mapping\n       Namespace to fill.  None results in new empty dict\n\n    Returns\n    -------\n    namespace : dict\n       dict with keys of implemented function names within ``expr`` and\n       corresponding values being the numerical implementation of\n       function\n\n    Examples\n    ========\n\n    >>> from sympy.abc import x\n    >>> from sympy.utilities.lambdify import implemented_function, _imp_namespace\n    >>> from sympy import Function\n    >>> f = implemented_function(Function('f'), lambda x: x+1)\n    >>> g = implemented_function(Function('g'), lambda x: x*10)\n    >>> namespace = _imp_namespace(f(g(x)))\n    >>> sorted(namespace.keys())\n    ['f', 'g']\n    \"\"\"\n    # Delayed import to avoid circular imports\n    from sympy.core.function import FunctionClass\n    if namespace is None:\n        namespace = {}\n    # tuples, lists, dicts are valid expressions\n    if is_sequence(expr):\n        for arg in expr:\n            _imp_namespace(arg, namespace)\n        return namespace\n    elif isinstance(expr, dict):\n        for key, val in expr.items():\n            # functions can be in dictionary keys\n            _imp_namespace(key, namespace)\n            _imp_namespace(val, namespace)\n        return namespace\n    # sympy expressions may be Functions themselves\n    func = getattr(expr, 'func', None)\n    if isinstance(func, FunctionClass):\n        imp = getattr(func, '_imp_', None)\n        if imp is not None:\n            name = expr.func.__name__\n            if name in namespace and namespace[name] != imp:\n                raise ValueError('We found more than one '\n                                 'implementation with name '\n                                 '\"%s\"' % name)\n            namespace[name] = imp\n    # and / or they may take Functions as arguments\n    if hasattr(expr, 'args'):\n        for arg in expr.args:\n            _imp_namespace(arg, namespace)\n    return namespace\n\n\ndef implemented_function(symfunc, implementation):\n    \"\"\" Add numerical ``implementation`` to function ``symfunc``.\n\n    ``symfunc`` can be an ``UndefinedFunction`` instance, or a name string.\n    In the latter case we create an ``UndefinedFunction`` instance with that\n    name.\n\n    Be aware that this is a quick workaround, not a general method to create\n    special symbolic functions. If you want to create a symbolic function to be\n    used by all the machinery of SymPy you should subclass the ``Function``\n    class.\n\n    Parameters\n    ----------\n    symfunc : ``str`` or ``UndefinedFunction`` instance\n       If ``str``, then create new ``UndefinedFunction`` with this as\n       name.  If ``symfunc`` is an Undefined function, create a new function\n       with the same name and the implemented function attached.\n    implementation : callable\n       numerical implementation to be called by ``evalf()`` or ``lambdify``\n\n    Returns\n    -------\n    afunc : sympy.FunctionClass instance\n       function with attached implementation\n\n    Examples\n    ========\n\n    >>> from sympy.abc import x\n    >>> from sympy.utilities.lambdify import lambdify, implemented_function\n    >>> f = implemented_function('f', lambda x: x+1)\n    >>> lam_f = lambdify(x, f(x))\n    >>> lam_f(4)\n    5\n    \"\"\"\n    # Delayed import to avoid circular imports\n    from sympy.core.function import UndefinedFunction\n    # if name, create function to hold implementation\n    kwargs = {}\n    if isinstance(symfunc, UndefinedFunction):\n        kwargs = symfunc._kwargs\n        symfunc = symfunc.__name__\n    if isinstance(symfunc, str):\n        # Keyword arguments to UndefinedFunction are added as attributes to\n        # the created class.\n        symfunc = UndefinedFunction(\n            symfunc, _imp_=staticmethod(implementation), **kwargs)\n    elif not isinstance(symfunc, UndefinedFunction):\n        raise ValueError(filldedent('''\n            symfunc should be either a string or\n            an UndefinedFunction instance.'''))\n    return symfunc\n", "meta": {"hexsha": "d9c2ef5b540292206a9788030537aef278d4a69d", "size": 50538, "ext": "py", "lang": "Python", "max_stars_repo_path": "sympy/utilities/lambdify.py", "max_stars_repo_name": "shilpiprd/sympy", "max_stars_repo_head_hexsha": "556e9c61b31d0d5f101cd56b43e843fbf3bcf121", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sympy/utilities/lambdify.py", "max_issues_repo_name": "shilpiprd/sympy", "max_issues_repo_head_hexsha": "556e9c61b31d0d5f101cd56b43e843fbf3bcf121", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sympy/utilities/lambdify.py", "max_forks_repo_name": "shilpiprd/sympy", "max_forks_repo_head_hexsha": "556e9c61b31d0d5f101cd56b43e843fbf3bcf121", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.3582733813, "max_line_length": 139, "alphanum_fraction": 0.6182872294, "include": true, "reason": "import numpy,from numpy,import scipy,from scipy,import sympy,from sympy,from mpmath,import cupy", "num_tokens": 12510, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.480478678047907, "lm_q2_score": 0.11436852920044106, "lm_q1q2_score": 0.05495163972051137}}
{"text": "# -*- coding: utf-8 -*-\n\"\"\"HW1 - COE426.ipynb\n\nAutomatically generated by Colaboratory.\n\nOriginal file is located at\n    \n\n#Abdullah Alnasser\n#201535050\n\"\"\"\n\n#import all needed libraries\nimport pandas as pd\nimport numpy as np\nimport sys, resource\nimport re\nimport plotly.express as px\nfrom scipy.stats import entropy\nimport random\n\n#unlock colab resources for infinite memory and recursion :)\nresource.setrlimit(resource.RLIMIT_STACK, (2**29,-1))\nsys.setrecursionlimit(10**6)\n\n#Set Columns of data set\nColumns = [\"Age\", \"Gender\", \"Marital\", \"Race_Status\", \"Birth_Place\", \"Language\", \"Occupation\", \"Income_(K)\"]\n\n#Load raw data set and append columns to it\nOriginal_DF = pd.read_csv(\"https://raw.githubusercontent.com/Alnasser0/COE426-HWs/master/HW1/ipums-assign1.csv\", names=Columns)\n\n#View data set\nOriginal_DF\n\n#Export data set (Can be viewed/download from left panel)\nOriginal_DF.to_csv('tablewithcolumns.csv', index=False)\n\n\"\"\"#Task1: Linkage attack (20 pts)\nDownload the file named ”ipums.txt” from blackboard and unzip\nit. Using Table 2 as external background information, perform\na data linkage attack to **find the annual salary of each person in\nthe table**. You are free to use any tool/programming language to\ncomplete this task, e.g., Excel, Python, Java, etc.\n\"\"\"\n\n#Load columns of table 2\nColumns2 = [\"Name\", \"Age\", \"Birth_Place\"]\n\n#Create a data frame and fill data of table 2\nTask1_DF = pd.DataFrame(columns=Columns2)\nTask1_DF=Task1_DF.append({'Name': \"Ahmed\", 'Age': 28, 'Birth_Place': 110}, ignore_index=True)\nTask1_DF=Task1_DF.append({'Name': \"Fatma\", 'Age': 44, 'Birth_Place': 4}, ignore_index=True)\nTask1_DF=Task1_DF.append({'Name': \"Ali\", 'Age': 17, 'Birth_Place': 199}, ignore_index=True)\nTask1_DF=Task1_DF.append({'Name': \"Abeer\", 'Age': 34, 'Birth_Place': 260}, ignore_index=True)\nTask1_DF=Task1_DF.append({'Name': \"Muhamad\", 'Age': 40, 'Birth_Place': 15}, ignore_index=True)\n\n#view table 2\nTask1_DF\n\n#Find the intersection of Original Data and Table 2\nmerged_inner = pd.merge(left=Task1_DF, right=Original_DF, on=['Age', 'Birth_Place'])\nmerged_inner\n\n\"\"\"#Sol of Task 1\n###We can see above that Ahmed income is 983K, Ali is 562K, Abeer is 536K, while Muhamad and Fatma cannot be determined due to different solutions, but we have narrowed their possibilities. If we had more attribute we could have got their salaries.\n\n-------------------------------------------------------------------\n\n#Task 2 - K-anonymization Implementation\nImplement the greedy partitioning algorithm that was discussed\nin the class using your preferred programming language. The sensitive attribute is Income. The remaining attributes are QuasiIdentifiers. The steps of the algorithm is shown in Figure 1.\nPlease read below for instructions on how to find and select the\nmean value.\n\"\"\"\n\n#Anonymize(partition) - done\n#if (no allowable multidimensional cut for partition) - done\n  #return Ø : partition → summary - done\n#else{ - done\n  #  dim ← choose_dimension() - done\n  #  fs ← frequency_set(partition, dim) - done\n  #  splitVal ← find_median(fs) - done\n  #  lhs ← {t Є partition : t:dim ≤ split} - done\n  #  rhs ← {t Є partition : t:dim > split} - done\n  #  return Anonymize(rhs) ∪ Anonymize(lhs) - done\n#} - done\n\n\"\"\"(a) Number of records (n) is odd: the median is the value at\nthe position n+1/2 of the sorted list of values.\n(b) Number of records (n) is even:\ni. Find the value at position n/2\nii. Find the value at position n/2 + 1\niii. The median is either of them.\n*the median is the value at the position n/2 of the sorted list\n\n###Note \nif you would like to try the functions and see their output, you can put print statement inside them and call them. You need to run them before calling them. I believe you should only use Numeric Quasi values for the HW code to work. Always assume the data you use in algorithm is similar to HW. For example, Columns of Quasi comes first and at the end the column of Sensetive values. Quasi values should be always numeric, but Sensetive I think can be any. Furthermore, it may not work if the data has other values than Sensetive and Quasi (Like unsensitive or Categorical). All these are assumptions, and may be wrong or true.\n\"\"\"\n\n#Initialize parameters of algorithm. YOU HAVE TO SET THEM.\nK = 9 #K Value, Can be changed later no worries\ncycles = 0 #Should always be 0 when first calling algorithm. Used to check if cant cut partition.\nSensitive = ['Income_(K)']\nQuasi = [\"Age\", \"Gender\", \"Marital\", \"Race_Status\", \"Birth_Place\", \"Language\", \"Occupation\"]\nColumns = [\"Age\", \"Gender\", \"Marital\", \"Race_Status\", \"Birth_Place\", \"Language\", \"Occupation\", \"Income_(K)\"]\n\n#A function of Anon Algorithm. \n#it returns text -Col name-, where dim_count between length of Quasi indexes\n#if the program is running ok, cycles<1, return dimension with highest Entropy (Shannon Entropy). \n#Why did I choose this method? To have the best cuts. Shanon Entropy tell us which data column has the highest evenly distrbuted data.\n#I thought first of using the Standard Div, but it is not good if the data is not distrbuted, as it depends heavely on mean, which can be\n#affected by outliers and make bad cuts in terms of privacy/utility.\n#If program is not running ok (Old_Part == Part or Cant Cut Part), \n#return Random Quasi column\ndef choose_dimension(table, cycles):\n  Entropies = []\n  for i in range(len(Quasi)):\n    series = table[Quasi[i]]\n    series = series.value_counts()\n    ColEntropy = entropy(series)\n    Entropies.append(ColEntropy)\n  if (cycles == 0):\n   return Quasi[Entropies.index(max(Entropies))]\n  else:\n   return Quasi[random.randint(0, len(Quasi)-1)]\n\n#A function of Anon Algorithm. \n#it returns frequency table of a dim.\n#IT IS NO LONGER USED BECAUSE IT MAKES Anonymize() INEFFICIENT.\ndef frequency_set(partition, dim):\n  fs = partition[dim].value_counts().to_frame().reset_index().rename(columns = {dim:'Count','index':dim}).sort_values(by=[dim])\n  return fs\n\n#A function of Anon Algorithm.\n#it returns median value of a column/pandas series based on HW criteria\ndef find_median(partition, dim):\n  if (len(partition[dim])%2 != 0): #if records odd\n    return np.median(partition[dim])\n  else:\n    return partition[dim].sort_values().iloc[int(len(partition[dim])/2-1)] #if even\n\n#A function of Anon Algorithm.\n#it returns True if the algorithm cant cut partition. \n#It is impossible to cut partition if the records are less than or equal K\ndef Cant_Cut(K, partition):\n  if(len(partition.index) <= K):\n    return True\n  else:\n    return False\n\n#A function of Anon Algorithm.\n#it returns a summarized partition. The function takes a partition, \n#extracts the Numerical values of Quasi columns, and it returns \n#a categorical table with upper and lower bound values of that table for\n#all Quasi columns.\ndef Summarize(partition):\n  if partition.empty:\n    return partition\n  else:\n    for i in range(len(partition.columns)-1):\n      partition[Quasi[i]] = pd.cut(partition[Quasi[i]], bins=[partition[Quasi[i]].min(), partition[Quasi[i]].max()+1], right=False)\n    return partition\n\n#Define calls and Anonymize Algorithm\ndef Anonymize(partition, K):\n  global Empty_Summary # Reference empty pandas dataframe to use for summary.\n  global cycles #A variable to use as a counter if partition or algorithm bugged.\n  if (Cant_Cut(K, partition) or cycles>=len(Quasi)): #if partition is minimum (cant cut more) or algorithm bugged\n    cycles = 0\n    Empty_Summary=Empty_Summary.append(Summarize(partition), ignore_index=True) #Append to output\n    #print(Empty_Summary) #Remove this comment if you want to see the process of Anonymize.\n    return\n  else: #function calls and logic\n    dim = choose_dimension(partition, cycles) #get dim\n    #fs = frequency_set(partition, dim) # NOT NEEDED, INEFFICIENT.\n    splitVal = find_median(partition, dim) #get median\n    lhs = partition[partition[dim] <= splitVal]\n    rhs = partition[partition[dim] > splitVal]\n    if (Cant_Cut(K, lhs) or Cant_Cut(K, rhs)): #dont allow cuts not allowed (partition less then K)\n      cycles = cycles+1 #increment bugged factor\n      Anonymize(partition, K) #find other random cut if possible\n      return\n    else:\n      cycles = 0\n    Anonymize(lhs, K) #keep partioning\n    Anonymize(rhs, K) #keep partioning\n    return\n\n#Initialize empty dataframe, so you can append the result of summarized partition\n#Get Copy of HW data set\n#apply alogrithm and save into Colab (Access from left panel).\n#Repeat\n#Uncomment the code if you want to try something.\n'''\nK=3\nEmpty_Summary=pd.DataFrame(columns=Columns)\nPartition = Original_DF.copy()\nAnonymize(Partition,K)\nEmpty_Summary.to_csv('Anon-K{}.csv'.format(K), index=False)\nK=5\nEmpty_Summary=pd.DataFrame(columns=Columns)\nPartition = Original_DF.copy()\nAnonymize(Partition,K)\nEmpty_Summary.to_csv('Anon-K{}.csv'.format(K), index=False)\nK=7\nEmpty_Summary=pd.DataFrame(columns=Columns)\nPartition = Original_DF.copy()\nAnonymize(Partition,K)\nEmpty_Summary.to_csv('Anon-K{}.csv'.format(K), index=False)\nK=9\nEmpty_Summary=pd.DataFrame(columns=Columns)\nPartition = Original_DF.copy()\nAnonymize(Partition,K)\nEmpty_Summary.to_csv('Anon-K{}.csv'.format(K), index=False)\n'''\n\n#Check empty_set from after applying the function.\n#Empty_Summary\n\n#Load output of Greedy Algorithm for K3.\nK3_Greedy = pd.read_csv(\"https://github.com/Alnasser0/COE426-HWs/raw/master/HW1/Anon-K3.csv\")\n\n#Validate that Empty_Set (Output) has classes >=K\ndef Validate(Table, K): #This algorithm checks every class if they violate k rule.\n  i=0 #index of row\n  while (i < len(Table.index)): #Stop when you reach record 20k, since last index 19999\n    selected_row=Table.iloc[i,:] #get a row.\n    same_class = Table[ #Get All Rows that have same Quasi Values (Same Class)\n            (Table.Age==selected_row.Age)\n          & (Table.Gender==selected_row.Gender) \n          & (Table.Marital==selected_row.Marital)\n          & (Table.Race_Status==selected_row.Race_Status)\n          & (Table.Birth_Place==selected_row.Birth_Place)\n          & (Table.Language==selected_row.Language)\n          & (Table.Occupation==selected_row.Occupation)\n    ]\n    number = len(same_class) #Get How many records in a class\n    if (number < K): #Return Violation and Class if values less than K\n      return same_class, True\n    i=i+len(same_class.index) #else continue iteration through the all classes\n  return _, False #if no violation is found, return to user.\n\n#test above algorithm\nK=3\nTable, Output_Boolean = Validate(K3_Greedy, K) #call method with call.\nif (Output_Boolean):\n  print(\"Greedy Algorithm does violate the rule of K={}, and the class is: \\n\".format(K))\n  print(Table)\nelse:\n  print(\"The Algorithm works ok and your table is safe! :)\")\n\n\"\"\"#Task 3 - Utility Privacy Trade-off\n###Using your implementation of the anonymization algorithm in\n###Task2, find the anonymized table with k=3,5,7, and 9.\n###For each anonymized table compute the Discernibility metric\n###CDM and generalized information loss ILOSS given by the following equations.\n###Then, draw a figure for each metric against the value of k to\n###depict the privacy trade off. The x-axis should be the value of K, Y=metric\n\"\"\"\n\n#These tables I made using ARX\nK3_ARX = pd.read_csv(\"https://raw.githubusercontent.com/Alnasser0/COE426-HWs/master/HW1/ARX-K3.csv\")\nK5_ARX = pd.read_csv(\"https://raw.githubusercontent.com/Alnasser0/COE426-HWs/master/HW1/ARX-K5.csv\")\nK7_ARX = pd.read_csv(\"https://raw.githubusercontent.com/Alnasser0/COE426-HWs/master/HW1/ARX-K7.csv\")\nK9_ARX = pd.read_csv(\"https://raw.githubusercontent.com/Alnasser0/COE426-HWs/master/HW1/ARX-K9.csv\")\n\n#These tables I made using above Greedy Algorithm\nK3_Greedy = pd.read_csv(\"https://github.com/Alnasser0/COE426-HWs/raw/master/HW1/Anon-K3.csv\")\nK5_Greedy = pd.read_csv(\"https://github.com/Alnasser0/COE426-HWs/raw/master/HW1/Anon-K5.csv\")\nK7_Greedy = pd.read_csv(\"https://github.com/Alnasser0/COE426-HWs/raw/master/HW1/Anon-K7.csv\")\nK9_Greedy = pd.read_csv(\"https://github.com/Alnasser0/COE426-HWs/raw/master/HW1/Anon-K9.csv\")\n\n\"\"\"You can use EITHER tables, my algorithm works on both :)\n- Make sure you set the correct parameters from Task 2.\n\"\"\"\n\ndef CDM(Table):\n  CDM = 0\n  i=0\n  while (i < len(Table.index)): #Stop when you reach record 20k, since last index 19999\n    selected_row=Table.iloc[i,:] #Select One Row\n    same_class = Table[ #Get All Rows that have same Quasi Values (Same Class)\n           (Table.Age==selected_row.Age)\n         & (Table.Gender==selected_row.Gender) \n         & (Table.Marital==selected_row.Marital)\n         & (Table.Race_Status==selected_row.Race_Status)\n         & (Table.Birth_Place==selected_row.Birth_Place)\n         & (Table.Language==selected_row.Language)\n         & (Table.Occupation==selected_row.Occupation)\n    ]\n    CDM = CDM + np.power(len(same_class.index), 2) #Apply Equation to a Class\n    i=i+len(same_class.index) #Increment Selected Row.\n  return CDM #Return CDM Value\n\n#This function calculates Denominator of I_LOSS\ndef Get_Denominator(table, attribute): #it takes Quasi + Table\n  Attribute_Column = table[Quasi[attribute]] #it selects Attribute\n  Attribute_Column = Attribute_Column.sort_values() #it sorts values\n  Attribute_Column = Attribute_Column[Attribute_Column != \"*\"] #Ignore * values for ARX\n  Attribute_Column = Attribute_Column[~Attribute_Column.str.contains(\">=\")] #Ignore >= values for ARX\n  Ui = Attribute_Column.iloc[len(Attribute_Column)-1] #Get Biggest Value in that Column.\n  Ui = [int(s) for s in re.findall('\\d+', Ui)] #Convert Text Value to Numeric List\n  Ui = Ui[1]-1 #Get Upper Bound Value\n  Li = Attribute_Column.iloc[0] #Get Smallest Value in that Column\n  Li = [int(s) for s in re.findall('\\d+', Li)] #Convert Text Value to Numeric List\n  Li = Li[0] #Get Lower Bound Value\n  Denominator = Ui-Li #Find Denominator\n  return Denominator #Return Denominator of that Column\n\ndef Get_Numerator(i, table, attribute_selection): #ith row, a table, attribute\n  selected_row=table.iloc[i,:] #Select a row\n  same_class = table[ #Get All Rows that have same Quasi Values (Same Class)\n           (table.Age==selected_row.Age)\n         & (table.Gender==selected_row.Gender) \n         & (table.Marital==selected_row.Marital)\n         & (table.Race_Status==selected_row.Race_Status)\n         & (table.Birth_Place==selected_row.Birth_Place)\n         & (table.Language==selected_row.Language)\n         & (table.Occupation==selected_row.Occupation)\n    ]\n  E = len(same_class.index) #Find Length of E Class (# of Records)\n  i=i+len(same_class.index) #Shift/Increment Selected Row.\n  cell = same_class.iloc[0,attribute_selection] #Get cell values in a Class\n  if ((\"*\" in cell) or (\">=\" in cell)): #ignore * and >= (for ARX)\n    return 0, 0, i #Return No Values, just i shift.\n  Cell_Values = [int(s) for s in re.findall('\\d+', cell)] #Get a cell values (We Assume all cells we have in Quasi columns contain 2 values (upper and lower) or have (*/>=) values!)\n  UpperCell = Cell_Values[1]-1 #Get Upper Bound Value\n  LowerCell = Cell_Values[0] #Get Lower Bound Value\n  Numerator = UpperCell-LowerCell #Find Numerator\n  return Numerator, E, i #Return Numerator, Class Size, and shifted i.\n\ndef GenCalc(table): #Loss function, only takes a table\n  GenLoss = 0 #intilize Gen. Loss.\n  AttributeLength = len(Quasi) #Get Columns length\n  attribute_selection = 0 #Initialize iterate value to go over columns\n  Cardinality_Table = len(table.index) #Get T Value\n  Coefficient = 1/(AttributeLength*Cardinality_Table) #Calculate Coefficient\n  i=0 #Start from First Row.\n  while (attribute_selection < AttributeLength): #Iterate over all columns, and for each do.\n    Den = Get_Denominator(table, attribute_selection) #Get Get_Denominator for that column.\n    while (i < len(table.index)): #Find Loss of each class for the selected column. #Stop when you reach record 20k, since last index 19999\n      Nom, E, i = Get_Numerator(i, table, attribute_selection) #Get Numerator of a Class with Class Size and Shifted Position.\n      GenLoss = GenLoss + (E*Nom)/Den #Calculate Loss of a complete class in a column. Then, continue doing it for all classes.\n    attribute_selection = attribute_selection+1 #do the same thing for next column\n    i = 0 #Reset Row Selection\n  return Coefficient*GenLoss #Return Value of Loss.\n\n#Call CDM function on a set of tables and store their result in an array.\n#These calculations will take time, uncomment and run on your responsibility\n\n#CDM_Answer_Greedy = [CDM(K3_Greedy),CDM(K5_Greedy),CDM(K7_Greedy),CDM(K9_Greedy)]\n#CDM_Answer_ARX = [CDM(K3_ARX),CDM(K5_ARX),CDM(K7_ARX),CDM(K9_ARX)]\n\n#Call I_Loss function on a set of tables and store their result in an array.\n#These calculations will take time, uncomment and run on your responsibility\n\n#I_Loss_Greedy = [GenCalc(K3_Greedy),GenCalc(K5_Greedy),GenCalc(K7_Greedy),GenCalc(K9_Greedy)]\n#I_Loss_ARX = [GenCalc(K3_ARX),GenCalc(K5_ARX),GenCalc(K7_ARX),GenCalc(K9_ARX)]\n\n#Define K Values in array.\nK = [3, 5, 7, 9]\n\n#Store values in a Frame to Plot them.\nCDM_Frame_Greedy = pd.DataFrame(data={'K':K,'CDM':CDM_Answer_Greedy})\nCDM_Frame_Greedy\n\n#Store values in a Frame to Plot them.\nCDM_Frame_ARX = pd.DataFrame(data={'K':K,'CDM':CDM_Answer_ARX})\nCDM_Frame_ARX\n\n#Store values in a Frame to Plot them.\nI_Loss_Frame_Greedy = pd.DataFrame(data={'K':K,'I_Loss':I_Loss_Greedy})\nI_Loss_Frame_Greedy\n\n#Store values in a Frame to Plot them.\nI_Loss_Frame_ARX = pd.DataFrame(data={'K':K,'I_Loss':I_Loss_ARX})\nI_Loss_Frame_ARX\n\n\"\"\"Most plots show that Loss increases as K increases, which reduces utility and increases privacy. Arx with l=2 has better I_Loss and Greedy algorithm has better CDM.\n\n### Greedy Algorithm Plots\n\"\"\"\n\nfig = px.line(CDM_Frame_Greedy, x=\"K\", y=\"CDM\")\nfig.show()\n\nfig = px.line(I_Loss_Frame_Greedy, x=\"K\", y=\"I_Loss\")\nfig.show()\n\n\"\"\"### ARX Plots\"\"\"\n\nfig = px.line(CDM_Frame_ARX, x=\"K\", y=\"CDM\")\nfig.show()\n\nfig = px.line(I_Loss_Frame_ARX, x=\"K\", y=\"I_Loss\")\nfig.show()\n\n\"\"\"#Task4: l-diversity\n###Using the anonymized table with k = 9 from Task 3, check if\n###the 9-anonymized table is distinct l-diverse for each l = 2 and 5.\n###In the case when the 9-anonymized table violates the l-diversity\n###requirements, print at least one equivalence class that violates\n###the diversity requirement.\n\"\"\"\n\n#Each should have class at least l' different values of Income(K) (>= l)\n\n#Load Task 3 Tables\nArx_Table = pd.read_csv(\"https://github.com/Alnasser0/COE426-HWs/raw/master/HW1/ARX-K9.csv\")\nGreedy_Table = pd.read_csv(\"https://github.com/Alnasser0/COE426-HWs/raw/master/HW1/Anon-K9.csv\")\n\ndef DoesViolateLdistinct(Table, l): #This algorithm checks every class if they violate l rule.\n  i=0 #index of row\n  while (i < len(Table.index)): #Stop when you reach record 20k, since last index 19999\n    selected_row=Table.iloc[i,:] #get a row.\n    same_class = Table[ #Get All Rows that have same Quasi Values (Same Class)\n            (Table.Age==selected_row.Age)\n          & (Table.Gender==selected_row.Gender) \n          & (Table.Marital==selected_row.Marital)\n          & (Table.Race_Status==selected_row.Race_Status)\n          & (Table.Birth_Place==selected_row.Birth_Place)\n          & (Table.Language==selected_row.Language)\n          & (Table.Occupation==selected_row.Occupation)\n      ]\n    if (all((~same_class.Age.str.contains(\"\\*\"))) and all((~same_class.Age.str.contains(\">=\")))): #Dont Check classes with * or >= values (For ARX)\n      number = len(same_class[\"Income_(K)\"].unique()) #Get How many unique sensetive values we have in a class\n      if (number < l): #Return Violation and Class if unique values is less than l\n       return same_class, True\n    i=i+len(same_class.index) #else continue iteration through the all classes\n  return _, False #if no violation is found, return to user.\n\nGreedy_Class_2, Greedy_Boolean_2 = DoesViolateLdistinct(Greedy_Table, 2)\nGreedy_Class_5, Greedy_Boolean_5 = DoesViolateLdistinct(Greedy_Table, 5)\nARX_Class_2, ARX_Boolean_2 = DoesViolateLdistinct(Arx_Table, 2)\nARX_Class_5, ARX_Boolean_5 = DoesViolateLdistinct(Arx_Table, 5)\n\nif (Greedy_Boolean_2):\n  print(\"Greedy Algorithm does violate the rule of l=2, and the class is: \\n\")\n  print(Greedy_Class_2)\nif (Greedy_Boolean_5):\n  print(\"\\nGreedy Algorithm does violate the rule of l=5, and the class is: \\n\")\n  print(Greedy_Class_5)\nif (ARX_Boolean_2):\n  print(\"\\nARX output does violate the rule of l=2, and the class is: \\n\")\n  print(ARX_Class_2)\nif (ARX_Boolean_5):\n  print(\"\\nARX output does violate the rule of l=5, and the class is: \\n\")\n  print(ARX_Class_5)", "meta": {"hexsha": "a2c68b954e397431d4edf25bcad2e8be99e5f2b9", "size": 20444, "ext": "py", "lang": "Python", "max_stars_repo_path": "HW1/hw1_coe426.py", "max_stars_repo_name": "Alnasser0/COE426-HWs", "max_stars_repo_head_hexsha": "1eda5f4d2ee1cf5843b49bc762b984d092bae706", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-02-20T21:47:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-20T21:47:15.000Z", "max_issues_repo_path": "HW1/hw1_coe426.py", "max_issues_repo_name": "Alnasser0/COE426-HWs", "max_issues_repo_head_hexsha": "1eda5f4d2ee1cf5843b49bc762b984d092bae706", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "HW1/hw1_coe426.py", "max_forks_repo_name": "Alnasser0/COE426-HWs", "max_forks_repo_head_hexsha": "1eda5f4d2ee1cf5843b49bc762b984d092bae706", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.6339285714, "max_line_length": 628, "alphanum_fraction": 0.7292115046, "include": true, "reason": "import numpy,from scipy", "num_tokens": 5740, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4301473631961697, "lm_q2_score": 0.1276526352779213, "lm_q1q2_score": 0.0549094444698402}}
{"text": "r\"\"\"\nInterface to Groebner Fan\n\nAUTHOR:\n\n- Anders Nedergaard Jensen: Write gfan C++ program, which implements\n  algorithms many of which were invented by Jensen, Komei\n  Fukuda, and Rekha Thomas.\n- William Stein (2006-03-18): wrote gfan interface (first version)\n- Marshall Hampton (2008-03-17): modified to use gfan-0.3, subprocess instead of os.popen2\n\nTODO -- much functionality of gfan-0.3 is still not exposed::\n\n   * at most 52 variables:\n\n       - use gfan_substitute to make easier (?)\n       MH: I think this is now irrelevant since gfan can accept the original ring variables\n\n   * --symmetry is really useful\n            - permutations are 0-based *not* cycle notation; a <---> 0\n     output is broken up much more nicely.\n\n   * -- can work in Z/pZ for p <= 32749\n\n   * -- can compute individual GB's for lex and revlex (via buchberger)\n\"\"\"\n\n# *****************************************************************************\n#       Copyright (C) 2006 William Stein <wstein@gmail.com>\n#\n#  Distributed under the terms of the GNU General Public License (GPL)\n#\n#    This code is distributed in the hope that it will be useful,\n#    but WITHOUT ANY WARRANTY; without even the implied warranty of\n#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n#    General Public License for more details.\n#\n#  The full text of the GPL is available at:\n#\n#                  http://www.gnu.org/licenses/\n# *****************************************************************************\n\nfrom subprocess import Popen, PIPE\n\nfrom sage.features.gfan import GfanExecutable\n\nfrom sage.misc.decorators import rename_keyword\n\nclass Gfan(object):\n    \"\"\"\n    Interface to Anders Jensen's Groebner Fan program.\n    \"\"\"\n    @rename_keyword(deprecation=33468, I='input')\n    def __call__(self, input, cmd='', verbose=False, format=None):\n        r\"\"\"\n        Call Groebner Fan program with given input\n\n        INPUT:\n\n        - ``input`` -- string, input\n        - ``cmd`` -- string (default:``''``), GFan command\n        - ``verbose`` -- bool (default:``False``)\n\n        EXAMPLES::\n\n            sage: print(gfan('Q[x,y]{x^2-y-1,y^2-xy-2/3}', cmd='bases')) # optional - gfan\n            Q[x,y]\n            {{\n            y^4+4/9-7/3*y^2-y^3,\n            x+5/2*y+3/2*y^2-3/2*y^3}\n            ,\n            {\n            x^2-1-y,\n            x*y+2/3-y^2,\n            y^3-5/3*y-y^2-2/3*x}\n            ,\n            {\n            x^2-1-y,\n            y^2-2/3-x*y}\n            ,\n            {\n            x^4+1/3+x-2*x^2-x^3,\n            y+1-x^2}\n            }\n\n        TESTS::\n\n            sage: _ = gfan(I='Q[x,y]{x^2-y-1,y^2-xy-2/3}', cmd='bases') # optional - gfan\n            doctest:...:\n            DeprecationWarning: use the option 'input' instead of 'I'\n            See https://trac.sagemath.org/33468 for details.\n\n        \"\"\"\n        if format is not None:\n            from sage.misc.superseded import deprecation\n            deprecation(33468, 'argument `format` is ignored in the code: '\n                               'it is now deprecated. Please update your code '\n                               'without this argument as it will be removed in a later '\n                               'version of SageMath.')\n\n        if cmd:\n            cmd = cmd.split(' ')\n            cmd[0] = GfanExecutable(cmd[0]).absolute_filename()\n        else:\n            cmd = [GfanExecutable().absolute_filename()]\n\n        if verbose:\n            print(\"gfan command:\\n%s\" % cmd)\n            print(\"gfan input:\\n%s\" % input)\n\n        gfan_processes = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE,\n                               encoding='latin-1')\n        ans, err = gfan_processes.communicate(input=input)\n\n        # sometimes, gfan outputs stuff to stderr even though everything is fine\n        # we avoid interpreting this as an error\n        if (len(err) > 0) and not (err.startswith('_application PolyhedralCone')):\n            raise RuntimeError(err)\n\n        return ans\n\n\n# The instance\ngfan = Gfan()\n", "meta": {"hexsha": "0e5b4046f4e0a92f8f8fe7fef212f29b12b689cd", "size": 4004, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/interfaces/gfan.py", "max_stars_repo_name": "LaisRast/sage", "max_stars_repo_head_hexsha": "5fb2a6ea44400e469caee82748cf863ca0c5f724", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/sage/interfaces/gfan.py", "max_issues_repo_name": "LaisRast/sage", "max_issues_repo_head_hexsha": "5fb2a6ea44400e469caee82748cf863ca0c5f724", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/interfaces/gfan.py", "max_forks_repo_name": "LaisRast/sage", "max_forks_repo_head_hexsha": "5fb2a6ea44400e469caee82748cf863ca0c5f724", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.032, "max_line_length": 91, "alphanum_fraction": 0.5474525475, "include": true, "reason": "from sage", "num_tokens": 1002, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.10970577242256814, "lm_q1q2_score": 0.05485288621128407}}
{"text": "\n\"\"\"\nshaping\n-------\nModule which groups the functions for shaping properly the arrays.\n\"\"\"\n\nimport numpy as np\n\n\ndef shaping_dim(array, ndim):\n    \"\"\"The dimensions of the array have to be least than ndim.\n\n    Parameters\n    ----------\n    array: np.ndarray\n        the array we want to format with the shape dimensions required.\n    ndim: int\n        the shape dimensions we want to format the input.\n\n    Returns\n    -------\n    array: np.ndarray\n        the array formatted in the shape dimensions required in the input.\n\n    \"\"\"\n\n    if array.ndim >= ndim:\n        return array\n    dim_extend = ndim - array.ndim\n    newshape = tuple(list(array.shape) + [1 for i in range(dim_extend)])\n    array = array.reshape(newshape)\n    return array\n\n\ndef ensure_2dim(array, axis=0, sh_known=(None, None)):\n    \"\"\"Ensure that the array input has two dimensions.\n\n    Parameters\n    ----------\n    array: np.ndarray\n        the array we want to ensure it has 2 dimensions.\n    axis: int (default=0)\n        the preferent axis.\n    sh_known: tuple (default=(None, None))\n        the known shape of the input.\n\n    Returns\n    -------\n    array: np.ndarray\n        the array formatted for 2 dimensions.\n\n    \"\"\"\n    ## Ensure 2 dimensions in the array\n    sh = array.shape\n    if len(sh) == 1:\n        new_sh = (sh[0], 1) if axis == 0 else (1, sh[0])\n    elif len(sh) == 2:\n        new_sh = sh\n    ## Ensure known shape\n    notnone_ids = [i for i in range(len(sh_known)) if sh_known[i] is not None]\n    if len(notnone_ids) == 0:\n        pass\n    if len(notnone_ids) == 1:\n        new_sh_notnone = [new_sh[i] for i in notnone_ids]\n        sh_known_notnone = [sh_known[i] for i in notnone_ids]\n        if new_sh_notnone == sh_known_notnone:\n            pass\n        elif new_sh_notnone[::-1] == sh_known_notnone:\n            new_sh = new_sh[::-1]\n        else:\n            raise Exception(\"Impossible to fit the conditions.\")\n    elif len(notnone_ids) == 2:\n        if new_sh == sh_known:\n            pass\n        elif new_sh[::-1] == sh_known:\n            new_sh = new_sh[::-1]\n        elif np.prod(new_sh) == np.prod(sh_known):\n            new_sh = sh_known\n        else:\n            raise Exception(\"Impossible to fit the conditions.\")\n    ## Transform array\n    array = array.reshape(new_sh)\n    return array\n", "meta": {"hexsha": "e794bb9e5aa6afc0afffd47647975b11a35ef234", "size": 2303, "ext": "py", "lang": "Python", "max_stars_repo_path": "pythonUtils/numpy_tools/shaping.py", "max_stars_repo_name": "tgquintela/pythonUtils", "max_stars_repo_head_hexsha": "6f2e5ba3be67a48d3cd5cf72dcabfae04cfa7afe", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2015-07-21T05:15:11.000Z", "max_stars_repo_stars_event_max_datetime": "2015-07-21T05:15:11.000Z", "max_issues_repo_path": "pythonUtils/numpy_tools/shaping.py", "max_issues_repo_name": "tgquintela/pythonUtils", "max_issues_repo_head_hexsha": "6f2e5ba3be67a48d3cd5cf72dcabfae04cfa7afe", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pythonUtils/numpy_tools/shaping.py", "max_forks_repo_name": "tgquintela/pythonUtils", "max_forks_repo_head_hexsha": "6f2e5ba3be67a48d3cd5cf72dcabfae04cfa7afe", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.0941176471, "max_line_length": 78, "alphanum_fraction": 0.5948762484, "include": true, "reason": "import numpy", "num_tokens": 576, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4726834766204328, "lm_q2_score": 0.115960721309117, "lm_q1q2_score": 0.05481271689980653}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Notebook\n\n# A Coronal Mass Ejection (CME) throws magnetic flux and plasma from the Sun into interplanetary space. These eruptions are actually related to solar flares -- in fact, CMEs and solar flares are considered “a single magnetically driven event” ([Webb & Howard 2012](http://adsabs.harvard.edu/abs/2012LRSP....9....3W)), wherein a flare unassociated with a CME is called a confined or compact flare. <br>\n# \n# In general, the more energetic a flare, the more likely it is to be associated with a CME ([Yashiro et al. 2005](http://adsabs.harvard.edu/abs/2005JGRA..11012S05Y)) -- but this is not, by any means, a rule. For example, [Sun et al. (2015)](http://adsabs.harvard.edu/abs/2015ApJ...804L..28S) found that the largest active region in the last 24 years, shown below, produced 6 X-class flares but not a single observed CME.<br>\n# \n# In this notebook, we will be predicting whether or not a flaring active region will also emit a CME using a machine learning algorithm from the scikit-learn package called Support Vector Machine.\n# \n# The analysis that follows is published in [Bobra & Ilonidis, 2016, <i> Astrophysical Journal</i>, 821, 127](http://adsabs.harvard.edu/abs/2016ApJ...821..127B). If you use any of this code, we ask that you cite Bobra & Ilonidis (2016).\n# \n# Here is a video that explains the difference between a flare and a CME:\n\n# In[1]:\n\n\nfrom IPython.display import YouTubeVideo\nYouTubeVideo(\"TWjtYSRlOUI\")\n\n\n# To do this analysis, we'll look at every active region observed by the Helioseismic and Magnetic Imager instrument on NASA's Solar Dynamics Observatory (SDO) satellite over the last eight years. Each active region is characterized by a bunch of features. These features describe the magnetic field at the solar surface. One feature, for example, is the total energy contained within an active region. Another is the total flux through an active region. We have 18 features, all of which are calculated every 12 minutes throughout an active region's lifetime. See [Bobra et al., 2014](http://link.springer.com/article/10.1007%2Fs11207-014-0529-3) for more information on how we calculate these features. <br>\n# \n# We'll then ascribe each active region to one of two classes:\n# \n# 1. The positive class contains flaring active regions that did produce a CME. \n# 2. The negative class contains flaring active regions that did not produce a CME. \n\n# First, we'll import some modules.\n\n# In[2]:\n\n\nimport numpy as np\nimport matplotlib.pylab as plt\nimport matplotlib.mlab as mlab\nimport pandas as pd\nimport scipy.stats\nimport requests\nimport urllib\nimport json\nfrom datetime import datetime as dt_obj\nfrom datetime import timedelta\nfrom sklearn import svm\nfrom sklearn.model_selection import StratifiedKFold\nfrom sunpy.time import TimeRange\nimport sunpy.instr.goes\nimport lime\nimport lime.lime_tabular\npd.set_option('display.max_rows', 500)\nget_ipython().run_line_magic('matplotlib', 'inline')\nget_ipython().run_line_magic('config', \"InlineBackend.figure_format = 'retina'\")\n\n\n# Now we'll gather the data. The data come from three different places: \n# \n# 1. CME data from SOHO/LASCO and STEREO/SECCHI coronographs, which can be accesed from the [DONKI database](http://kauai.ccmc.gsfc.nasa.gov/DONKI/) at NASA Goddard. This tells us if an active region has produced a CME or not.\n# 2. Flare data from the GOES flare catalog at NOAA, which can be accessed with the `sunpy.instr.goes.get_event_list()` function. This tells us if an active region produced a flare or not.\n# 3. Active region data from the Solar Dynamics Observatory's Heliosesmic and Magnetic Imager instrument, which can be accessed from the [JSOC database](http://jsoc.stanford.edu/) via a JSON API. This gives us the features characterizing each active region.\n\n# ## Step 1: Gathering data for the positive class\n\n# Let's first query the [DONKI database](http://kauai.ccmc.gsfc.nasa.gov/DONKI/) to get the data associated with the positive class. Be forewarned: there's a lot of data cleaning involved with building the positive class.\n\n# In[3]:\n\n\n# request the data\nbaseurl = \"https://kauai.ccmc.gsfc.nasa.gov/DONKI/WS/get/FLR?\"\nt_start = \"2010-05-01\"\nt_end = \"2018-04-01\"\nurl = baseurl+\"startDate=\"+t_start+\"&endDate=\"+t_end\n\n# if there's no response at this time, print warning\nresponse = requests.get(url)\nif response.status_code != 200:\n    print('cannot successfully get an http response')\n\n\n# In[4]:\n\n\n# read the data\n\nprint(\"Getting data from\", url)\ndf = pd.read_json(url)\n\n# select flares associated with a linked event (SEP or CME), and\n# select only M or X-class flares\nevents_list = df.loc[df['classType'].str.contains(\n    \"M|X\") & ~df['linkedEvents'].isnull()]\n\n# drop all rows that don't satisfy the above conditions\nevents_list = events_list.reset_index(drop=True)\n\n\n# In[5]:\n\n\n# drop the rows that aren't linked to CME events\nfor i in range(events_list.shape[0]):\n    value = events_list.loc[i]['linkedEvents'][0]['activityID']\n    if not \"CME\" in value:\n        print(value, \"not a CME, dropping row\")\n        events_list = events_list.drop([i])\nevents_list = events_list.reset_index(drop=True)\n\n\n# Convert the `peakTime` column in the `events_list` dataframe from a string into a datetime object:\n\n# In[6]:\n\n\ndef parse_tai_string(tstr):\n    year = int(tstr[:4])\n    month = int(tstr[5:7])\n    day = int(tstr[8:10])\n    hour = int(tstr[11:13])\n    minute = int(tstr[14:16])\n    return dt_obj(year, month, day, hour, minute)\n\n\nfor i in range(events_list.shape[0]):\n    events_list['peakTime'].iloc[i] = parse_tai_string(\n        events_list['peakTime'].iloc[i])\n\n\n# Check for Case 1: In this case, the CME and flare exist but NOAA active region number does not exist in the DONKI database.\n\n# In[7]:\n\n\n# Case 1: CME and Flare exist but NOAA active region number does not exist in DONKI database\n\nnumber_of_donki_mistakes = 0  # count the number of DONKI mistakes\n# create an empty array to hold row numbers to drop at the end\nevent_list_drops = []\n\nfor i in range(events_list.shape[0]):\n    if (np.isnan(events_list.loc[i]['activeRegionNum'])):\n        time = events_list['peakTime'].iloc[i]\n        time_range = TimeRange(time, time)\n        listofresults = sunpy.instr.goes.get_goes_event_list(time_range, 'M1')\n        if (listofresults[0]['noaa_active_region'] == 0):\n            print(events_list.loc[i]['activeRegionNum'], events_list.loc[i]\n                  ['classType'], \"has no match in the GOES flare database ; dropping row.\")\n            event_list_drops.append(i)\n            number_of_donki_mistakes += 1\n            continue\n        else:\n            print(\"Missing NOAA number:\", events_list['activeRegionNum'].iloc[i], events_list['classType'].iloc[i],\n                  events_list['peakTime'].iloc[i], \"should be\", listofresults[0]['noaa_active_region'], \"; changing now.\")\n            events_list['activeRegionNum'].iloc[i] = listofresults[0]['noaa_active_region']\n            number_of_donki_mistakes += 1\n\n# Drop the rows for which there is no active region number in both the DONKI and GOES flare databases\nevents_list = events_list.drop(event_list_drops)\nevents_list = events_list.reset_index(drop=True)\nprint('There are', number_of_donki_mistakes, 'DONKI mistakes so far.')\n\n\n# Now we grab all the data from the GOES database in preparation for checking Cases 2 and 3.\n\n# In[8]:\n\n\n# Grab all the data from the GOES database\ntime_range = TimeRange(t_start, t_end)\nlistofresults = sunpy.instr.goes.get_goes_event_list(time_range, 'M1')\nprint('Grabbed all the GOES data; there are', len(listofresults), 'events.')\n\n\n# Check for Case 2: In this case, the NOAA active region number is wrong in the DONKI database.\n\n# In[9]:\n\n\n# Case 2: NOAA active region number is wrong in DONKI database\n\n# collect all the peak flares times in the NOAA database\npeak_times_noaa = [item[\"peak_time\"] for item in listofresults]\n\nfor i in range(events_list.shape[0]):\n    # check if a particular DONKI flare peak time is also in the NOAA database\n    peak_time_donki = events_list['peakTime'].iloc[i]\n    if peak_time_donki in peak_times_noaa:\n        index = peak_times_noaa.index(peak_time_donki)\n    else:\n        continue\n    # ignore NOAA active region numbers equal to zero\n    if (listofresults[index]['noaa_active_region'] == 0):\n        continue\n    # if yes, check if the DONKI and NOAA active region numbers match up for this peak time\n    # if they don't, flag this peak time and replace the DONKI number with the NOAA number\n    if (listofresults[index]['noaa_active_region'] != int(events_list['activeRegionNum'].iloc[i])):\n        print('Messed up NOAA number:', int(events_list['activeRegionNum'].iloc[i]), events_list['classType'].iloc[i],\n              events_list['peakTime'].iloc[i], \"should be\", listofresults[index]['noaa_active_region'], \"; changing now.\")\n        events_list['activeRegionNum'].iloc[i] = listofresults[index]['noaa_active_region']\n        number_of_donki_mistakes += 1\nprint('There are', number_of_donki_mistakes, 'DONKI mistakes so far.')\n\n\n# Check for Case 3: In this case, the flare peak time is wrong in the DONKI database.\n\n# In[10]:\n\n\n# Case 3: The flare peak time is wrong in the DONKI database.\n\n# create an empty array to hold row numbers to drop at the end\nevent_list_drops = []\n\nactive_region_numbers_noaa = [item[\"noaa_active_region\"]\n                              for item in listofresults]\nflare_classes_noaa = [item[\"goes_class\"] for item in listofresults]\n\nfor i in range(events_list.shape[0]):\n    # check if a particular DONKI flare peak time is also in the NOAA database\n    peak_time_donki = events_list['peakTime'].iloc[i]\n    if not peak_time_donki in peak_times_noaa:\n        active_region_number_donki = int(\n            events_list['activeRegionNum'].iloc[i])\n        flare_class_donki = events_list['classType'].iloc[i]\n        flare_class_indices = [i for i, x in enumerate(\n            flare_classes_noaa) if x == flare_class_donki]\n        active_region_indices = [i for i, x in enumerate(\n            active_region_numbers_noaa) if x == active_region_number_donki]\n        common_indices = list(\n            set(flare_class_indices).intersection(active_region_indices))\n        if common_indices:\n            print(\"Messed up time:\", int(events_list['activeRegionNum'].iloc[i]), events_list['classType'].iloc[i],\n                  events_list['peakTime'].iloc[i], \"should be\", peak_times_noaa[common_indices[0]], \"; changing now.\")\n            events_list['peakTime'].iloc[i] = peak_times_noaa[common_indices[0]]\n            number_of_donki_mistakes += 1\n        if not common_indices:\n            print(\"DONKI flare peak time\",\n                  events_list['peakTime'].iloc[i], \"has no match; dropping row.\")\n            event_list_drops.append(i)\n            number_of_donki_mistakes += 1\n\n# Drop the rows for which the NOAA active region number and flare class associated with\n# the messed-up flare peak time in the DONKI database has no match in the GOES flare database\nevents_list = events_list.drop(event_list_drops)\nevents_list = events_list.reset_index(drop=True)\n\n# Create a list of corrected flare peak times\npeak_times_donki = [events_list['peakTime'].iloc[i]\n                    for i in range(events_list.shape[0])]\n\nprint('There are', number_of_donki_mistakes, 'DONKI mistakes so far.')\n\n\n# This is our final table of events that fall into the positive class:\n\n# In[11]:\n\n\nevents_list\n\n\n# Now let's query the JSOC database to see if there are active region parameters at the time of the flare. First read the following file to map NOAA active region numbers to HARPNUMs (a HARP, or an HMI Active Region Patch, is the preferred numbering system for the HMI active regions as they appear in the magnetic field data before NOAA observes them in white light):\n\n# In[12]:\n\n\nanswer = pd.read_csv(\n    'http://jsoc.stanford.edu/doc/data/hmi/harpnum_to_noaa/all_harps_with_noaa_ars.txt', sep=' ')\n\n\n# Now, let's determine at which time we'd like to predict CMEs. In general, many people try to predict a CME either 24 or 48 hours before it happens. We can report both in this study by setting a variable called `timedelayvariable`:\n\n# In[13]:\n\n\ntimedelayvariable = 24\n\n\n# Now, we'll convert subtract `timedelayvariable` from the GOES Peak Time and re-format the datetime object into a string that JSOC can understand:\n\n# In[14]:\n\n\nt_rec = [(events_list['peakTime'].iloc[i] - timedelta(hours=timedelayvariable)\n          ).strftime('%Y.%m.%d_%H:%M_TAI') for i in range(events_list.shape[0])]\n\n\n# Now we can grab the SDO data from the JSOC database by executing the JSON queries. We are selecting data that satisfies several criteria: The data has to be [1] disambiguated with a version of the disambiguation module greater than 1.1, [2] taken while the orbital velocity of the spacecraft is less than 3500 m/s, [3] of a high quality, and [4] within 70 degrees of central meridian. If the data pass all these tests, they are stuffed into one of two lists: one for the positive class (called CME_data) and one for the negative class (called no_CME_data).\n\n# In[15]:\n\n\ndef get_the_jsoc_data(event_count, t_rec):\n    \"\"\"\n    Parameters\n    ----------\n    event_count: number of events \n                 int\n\n    t_rec:       list of times, one associated with each event in event_count\n                 list of strings in JSOC format ('%Y.%m.%d_%H:%M_TAI')\n\n    \"\"\"\n\n    catalog_data = []\n    classification = []\n\n    for i in range(event_count):\n\n        print(\"=====\", i, \"=====\")\n        # next match NOAA_ARS to HARPNUM\n        idx = answer[answer['NOAA_ARS'].str.contains(\n            str(int(listofactiveregions[i])))]\n\n        # if there's no HARPNUM, quit\n        if (idx.empty == True):\n            print('skip: there are no matching HARPNUMs for',\n                  str(int(listofactiveregions[i])))\n            continue\n\n        # construct jsoc_info queries and query jsoc database; we are querying for 25 keywords\n        url = \"http://jsoc.stanford.edu/cgi-bin/ajax/jsoc_info?ds=hmi.sharp_720s[\"+str(\n            idx.HARPNUM.values[0])+\"][\"+t_rec[i]+\"][? (CODEVER7 !~ '1.1 ') and (abs(OBS_VR)< 3500) and (QUALITY<65536) ?]&op=rs_list&key=USFLUX,MEANGBT,MEANJZH,MEANPOT,SHRGT45,TOTUSJH,MEANGBH,MEANALP,MEANGAM,MEANGBZ,MEANJZD,TOTUSJZ,SAVNCPP,TOTPOT,MEANSHR,AREA_ACR,R_VALUE,ABSNJZH\"\n        response = requests.get(url)\n\n        # if there's no response at this time, quit\n        if response.status_code != 200:\n            print('skip: cannot successfully get an http response')\n            continue\n\n        # read the JSON output\n        data = response.json()\n\n        # if there are no data at this time, quit\n        if data['count'] == 0:\n            print('skip: there are no data for HARPNUM',\n                  idx.HARPNUM.values[0], 'at time', t_rec[i])\n            continue\n\n        # check to see if the active region is too close to the limb\n        # we can compute the latitude of an active region in stonyhurst coordinates as follows:\n        # latitude_stonyhurst = CRVAL1 - CRLN_OBS\n        # for this we have to query the CEA series (but above we queried the other series as the CEA series does not have CODEVER5 in it)\n\n        url = \"http://jsoc.stanford.edu/cgi-bin/ajax/jsoc_info?ds=hmi.sharp_cea_720s[\"+str(\n            idx.HARPNUM.values[0])+\"][\"+t_rec[i]+\"][? (abs(OBS_VR)< 3500) and (QUALITY<65536) ?]&op=rs_list&key=CRVAL1,CRLN_OBS\"\n        response = requests.get(url)\n\n        # if there's no response at this time, quit\n        if response.status_code != 200:\n            print('skip: failed to find CEA JSOC data for HARPNUM',\n                  idx.HARPNUM.values[0], 'at time', t_rec[i])\n            continue\n\n        # read the JSON output\n        latitude_information = response.json()\n\n        # if there are no data at this time, quit\n        if latitude_information['count'] == 0:\n            print('skip: there are no data for HARPNUM',\n                  idx.HARPNUM.values[0], 'at time', t_rec[i])\n            continue\n\n        CRVAL1 = float(latitude_information['keywords'][0]['values'][0])\n        CRLN_OBS = float(latitude_information['keywords'][1]['values'][0])\n        if (np.absolute(CRVAL1 - CRLN_OBS) > 70.0):\n            print('skip: latitude is out of range for HARPNUM',\n                  idx.HARPNUM.values[0], 'at time', t_rec[i])\n            continue\n\n        if ('MISSING' in str(data['keywords'])):\n            print('skip: there are some missing keywords for HARPNUM',\n                  idx.HARPNUM.values[0], 'at time', t_rec[i])\n            continue\n\n        print('accept NOAA Active Region number', str(int(\n            listofactiveregions[i])), 'and HARPNUM', idx.HARPNUM.values[0], 'at time', t_rec[i])\n\n        individual_flare_data = []\n        for j in range(18):\n            individual_flare_data.append(\n                float(data['keywords'][j]['values'][0]))\n\n        catalog_data.append(list(individual_flare_data))\n\n        single_class_instance = [idx.HARPNUM.values[0], str(\n            int(listofactiveregions[i])), listofgoesclasses[i], t_rec[i]]\n        classification.append(single_class_instance)\n\n    return catalog_data, classification\n\n\n# Now we prepare the data to be fed into the function:\n\n# In[16]:\n\n\nlistofactiveregions = list(events_list['activeRegionNum'].values.flatten())\nlistofgoesclasses = list(events_list['classType'].values.flatten())\n\n\n# And call the function:\n\n# In[17]:\n\n\npositive_result = get_the_jsoc_data(events_list.shape[0], t_rec)\n\n\n# Here is the number of events associated with the positive class:\n\n# In[18]:\n\n\nCME_data = positive_result[0]\npositive_class = positive_result[1]\nprint(\"There are\", len(CME_data), \"CME events in the positive class.\")\n\n\n# ## Step 2: Gathering data for the negative class\n\n# To gather the examples for the negative class, we only need to:\n# \n# 1. Query the GOES database for all the M- and X-class flares during our time of interest, and\n# 2. Select the ones that are not associated with a CME. \n\n# In[19]:\n\n\n# select peak times that belong to both classes\nall_peak_times = np.array([(listofresults[i]['peak_time'])\n                           for i in range(len(listofresults))])\n\nnegative_class_possibilities = []\ncounter_positive = 0\ncounter_negative = 0\nfor i in range(len(listofresults)):\n    this_peak_time = all_peak_times[i]\n    if (this_peak_time in peak_times_donki):\n        counter_positive += 1\n    else:\n        counter_negative += 1\n        this_instance = [listofresults[i]['noaa_active_region'],\n                         listofresults[i]['goes_class'], listofresults[i]['peak_time']]\n        negative_class_possibilities.append(this_instance)\nprint(\"There are\", counter_positive, \"events in the positive class.\")\nprint(\"There are\", counter_negative, \"events in the negative class.\")\n\n\n# Again, we compute times that are one day before the flare peak time and convert it into a string that JSOC can understand:\n\n# In[20]:\n\n\nt_rec = np.array([(negative_class_possibilities[i][2] - timedelta(hours=timedelayvariable)\n                   ).strftime('%Y.%m.%d_%H:%M_TAI') for i in range(len(negative_class_possibilities))])\n\n\n# And again, we query the JSOC database to see if these data are present:\n\n# In[21]:\n\n\nlistofactiveregions = list(\n    negative_class_possibilities[i][0] for i in range(counter_negative))\nlistofgoesclasses = list(\n    negative_class_possibilities[i][1] for i in range(counter_negative))\n\n\n# In[22]:\n\n\nnegative_result = get_the_jsoc_data(counter_negative, t_rec)\n\n\n# Here is the number of events associated with the negative class:\n\n# In[23]:\n\n\nno_CME_data = negative_result[0]\nnegative_class = negative_result[1]\nprint(\"There are\", len(no_CME_data), \"no-CME events in the negative class.\")\n\n\n# ## Step 3: Feature selection\n\n# Some of the features within a data set may be powerful for distinguishing between the positive and negative class, whereas others may be redundant or irrelevant. To identify features in the former category, we use a univariate feature selection method, which is implemented in the feature selection module of the scikit-learn library, for feature scoring.\n\n# To improve the performance of the feature selection algorithm, we'll normalize each feature so that they lie within similar ranges. To do this, we subtract from every feature its median value and divide by its standard deviation.\n\n# In[24]:\n\n\nCME_data = np.array(CME_data)\nno_CME_data = np.array(no_CME_data)\n\n\n# In[25]:\n\n\ndef normalize_the_data(flare_data):\n    flare_data = np.array(flare_data)\n    n_elements = flare_data.shape[0]\n    for j in range(flare_data.shape[1]):\n        standard_deviation_of_this_feature = np.std(flare_data[:, j])\n        median_of_this_feature = np.median(flare_data[:, j])\n        for i in range(n_elements):\n            flare_data[i, j] = (\n                flare_data[i, j] - median_of_this_feature) / (standard_deviation_of_this_feature)\n    return flare_data\n\n\nno_CME_data = normalize_the_data(no_CME_data)\nCME_data = normalize_the_data(CME_data)\n\nprint(\"There are\", no_CME_data.shape[0], \"flares with no associated CMEs.\")\nprint(\"There are\", CME_data.shape[0], \"flares with associated CMEs.\")\n\n\n# Let's look at the distribution of one feature for the active regions that both flared and produced a CME (green) and for the active regions that flared but did not produce a CME (red). You can change the value of `i` in the code block below to see that some features are totally useless as there is barely any difference in the distributions for the positive and negative class. As such, we can throw such features out of our sample. It's a good idea to do some feature selection before running the SVM, so as to reduce noise (in this case, with only 18 features, there's not too much noise to begin with). \n\n# In[26]:\n\n\nsharps = ['Total unsigned flux', 'Mean gradient of total field',\n          'Mean current helicity (Bz contribution)', 'Mean photospheric magnetic free energy',\n          'Fraction of Area with Shear > 45 deg', 'Total unsigned current helicity',\n          'Mean gradient of horizontal field', 'Mean characteristic twist parameter, alpha',\n          'Mean angle of field from radial', 'Mean gradient of vertical field',\n          'Mean vertical current density', 'Total unsigned vertical current',\n          'Sum of the modulus of the net current per polarity',\n          'Total photospheric magnetic free energy density', 'Mean shear angle',\n          'Area of strong field pixels in the active region', 'Sum of flux near polarity inversion line',\n          'Absolute value of the net current helicity']\n\ni = 2\n\n# For the positive class (green)\nmu_fl = np.mean(CME_data[:, i])\nsigma_fl = np.std(CME_data[:, i])\nnum_bins = 15\nn_fl, bins_fl, patches_fl = plt.hist(\n    CME_data[:, i], num_bins, normed=1, facecolor='green', alpha=0.5)\ny_fl = scipy.stats.norm.pdf(bins_fl, mu_fl, sigma_fl)\nplt.plot(bins_fl, y_fl, 'g--', label='positive class')\n\n# For the negative class (red)\nmu_nofl = np.mean(no_CME_data[:, i])\nsigma_nofl = np.std(no_CME_data[:, i])\nn_nofl, bins_nofl, patches_nofl = plt.hist(\n    no_CME_data[:, i], num_bins, normed=1, facecolor='red', alpha=0.5)\ny_nofl = scipy.stats.norm.pdf(bins_nofl, mu_nofl, sigma_nofl)\nplt.plot(bins_nofl, y_nofl, 'r--', label='negative class')\n\ntext_style = dict(fontsize=16, fontdict={'family': 'monospace'})\nplt.xlabel('Normalized '+sharps[i], **text_style)\nplt.ylabel('Number (normalized)', labelpad=20, **text_style)\nfig = plt.gcf()\nfig.set_size_inches(10, 5)\nfig.savefig('fscore_tmp.png', bbox_inches='tight')\nlegend = plt.legend(loc='upper right', fontsize=12, framealpha=0.0, title='')\nlegend.get_frame().set_linewidth(0.0)\n\n\n# Now we will compute the Univariate F-score for feature selection. It is a very simple method: the F-score measures the distance between the two distributions for a given feature (inter-class distance), divided by the sum of the variances for this feature (intra-class distance). We can use the `sklearn.feature_selection` module to do this:\n\n# In[27]:\n\n\n# import the feature selection method\nfrom sklearn.feature_selection import SelectKBest, f_classif\n# select the number of features\nN_features = 18\nNfl = CME_data.shape[0]\nNnofl = no_CME_data.shape[0]\nyfl = np.ones(Nfl)\nynofl = np.zeros(Nnofl)\n# k is the number of features\nselector = SelectKBest(f_classif, k=N_features)\nselector.fit(np.concatenate((CME_data, no_CME_data), axis=0),\n             np.concatenate((yfl, ynofl), axis=0))\nscores = selector.scores_\nprint(scores)\n\n\n# It's not easy to interpret the scores in this fashion, so let's plot the results. The higher the Univariate Fisher Score, the more predictive the feature.\n\n# In[28]:\n\n\nplt.clf()\norder = np.argsort(scores)\norderedsharps = [sharps[i] for i in order]\ny_pos2 = np.arange(18)\nplt.barh(y_pos2, sorted(scores/np.max(scores)))\nplt.ylim((-1, 19))\nplt.yticks(y_pos2, orderedsharps, fontsize=12)\nplt.xlabel('Normalized Fisher Score', fontsize=15)\nplt.title('Normalized Univariate Fisher Score Per Feature', fontsize=15)\nplt.subplots_adjust(left=0.5, right=1.0)\nfig = plt.gcf()\nfig.set_size_inches(9, 5)\nplt.show()\n\n\n# ## Step 4: The support vector machine\n\n# Now we initialize the support vector machine on the data. The SVM uses non-linear decision functions to map the feature space into a higher-dimensional space, where the positive and negative examples can be separated linearly by a hyperplane. <br>\n# \n# This is incredibly non-intuitive. But we can think of a simpler example. Suppose we had two classes: CME-producing and non-CME producing active regions. And suppose we had two features: the total flux in these regions, and the total area of these regions. We could construct a two-dimentional feature space, where we plot the flux against the area of each active region. Positive examples could be indicated by an X and negatives ones by an O. In theory, if our data behaved well, we could draw a line between these classess. <br>\n# \n# Since we have 18 features, the SVM constructs an 18-dimensional feature space. In this feature space, the decision boundary separating the positive and negative examples may be non-linear. As such, the algorithm then enlarges this 18-dimensional feature space (using the function indicated by the `kernel` parameter in the [`svm.SVC`](http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html) function) into a higher-dimensional feature space wherein it is possible to linearly separate the positive and negatives classes. There are lots of people trying to work on how to [visualize these multi-dimensional feature spaces](https://github.com/tmadl/highdimensional-decision-boundary-plot), which is an active area of research.\n\n# In[29]:\n\n\nnumber_of_examples = Nfl + Nnofl\nC = 4.0\ngamma = 0.075\nclass_weight = {1: 6.5}\nclf = svm.SVC(C=C, gamma=gamma, kernel='rbf', class_weight=class_weight,\n              cache_size=500, max_iter=-1, shrinking=True, tol=1e-8, probability=True)\n\n\n# ## Step 5: Stratified k-folds cross-validation\n\n# Now we run and evaluate the performance of the SVM. There are lots of different ways to evaluate the performance of a classifier, which we discuss in Section 4 of [Bobra & Couvidat (2015)](https://arxiv.org/abs/1411.1405). We're going to choose a metric called the True Skill Score, or the TSS, which we can calculate from four quantities: true positives, true negatives, false positives, and false negatives. We prefer the TSS to all the other metrics as it is insensitive to the class imbalance ratio and thus best for comparison to other groups. The TSS is symmetrically distributed about 0: i.e., it goes from [-1, 1] where 0 represents no skill and a negative value represents a perverse prediction. Thus we are able to predict CMEs in a fashion better than randomly guessing. Here we define a confusion table to measure the performance of our binary classification: <br>\n\n# In[30]:\n\n\ndef confusion_table(pred, labels):\n    \"\"\"\n    computes the number of TP, TN, FP, FN events given the arrays with predictions and true labels\n    and returns the true skill score\n\n    Args:\n    pred: np array with predictions (1 for flare, 0 for nonflare)\n    labels: np array with true labels (1 for flare, 0 for nonflare)\n\n    Returns: true negative, false positive, true positive, false negative\n    \"\"\"\n    Nobs = len(pred)\n    TN = 0.\n    TP = 0.\n    FP = 0.\n    FN = 0.\n    for i in range(Nobs):\n        if (pred[i] == 0 and labels[i] == 0):\n            TN += 1\n        elif (pred[i] == 1 and labels[i] == 0):\n            FP += 1\n        elif (pred[i] == 1 and labels[i] == 1):\n            TP += 1\n        elif (pred[i] == 0 and labels[i] == 1):\n            FN += 1\n        else:\n            print(\"Error! Observation could not be classified.\")\n    return TN, FP, TP, FN\n\n\n# Now we run the SVM on our data and cross-validate our results. In our case, the positive sample size is quite small (both objectively and compared to the negative sample size). Therefore, we use a stratified k-folds cross-validation method, which makes k partitions of the data set and uses k-1 folds for training the SVM and 1 fold for testing the trained SVM. The stratification preserves the ratio of positive to negative examples per fold. Then we can permute over the partitions such that each partition eventually makes its way into the testing set. For each individual testing set, we can calculate a skill score. Then we can average the skill scores over the total number of testing sets. \n# \n# To compute the TSS, we must first select a value of k. k can be arbitrarily defined and take any value between 2 and `number_of_examples`, so we can explore this parameter space. As k approaches `number_of_examples`, the k-fold method reduces to the Leave One Out method, in which only one example is in the testing set and all other examples are in the training set. The literature suggests this method is not the best, so we can stray away from high values of k. Many studies (e.g. [Kohavi, 1995](http://web.cs.iastate.edu/~jtian/cs573/Papers/Kohavi-IJCAI-95.pdf)) recommend the stratified 10-fold cross-validation to reduce variance and bias. Here, we test their recommendation by computing the TSS using 50 k values, ranging from 2 to 52. \n\n# In[31]:\n\n\n# lists to hold the TSS and standard deviation of the TSS\narray_of_avg_TSS = np.ndarray([50])\narray_of_std_TSS = np.ndarray([50])\n\n# xdata are the examples\n# ydata are the labels\nxdata = np.concatenate((CME_data, no_CME_data), axis=0)\nydata = np.concatenate((np.ones(Nfl), np.zeros(Nnofl)), axis=0)\n\n# mdata contain metadata about the active region that will be useful\n# when we interpret the results using LIME\nmdata = np.concatenate((positive_class, negative_class), axis=0)\n\n# compute the TSS for a variety of k ranging from 2 to 52\n# this is to see how the TSS varies as a function of k, and to test if k=10 really makes sense\nfor k in range(2, 52):\n    skf = StratifiedKFold(n_splits=k, shuffle=True)\n    these_TSS_for_this_k = []\n    for train_index, test_index in skf.split(xdata, ydata):\n        # xtrain are the examples in the training set\n        xtrain = xdata[train_index]\n        # ytrain are the labels in the training set\n        ytrain = ydata[train_index]\n        # xtest are the examples in the testing set\n        xtest = xdata[test_index]\n        ytest = ydata[test_index]    # ytest are the labels in the testing set\n        # metadata useful for interpreting with LIME\n        mtrain = mdata[train_index]\n        # metadata useful for interpreting with LIME\n        mtest = mdata[test_index]\n        clf.fit(xtrain, ytrain)\n        TN, FP, TP, FN = confusion_table(clf.predict(xtest), ytest)\n        if (((TP+FN) == 0.0) or (FP+TN) == 0.0):\n            these_TSS_for_this_k.append(np.nan)\n            continue\n        else:\n            these_TSS_for_this_k.append(TP/(TP+FN) - FP/(FP+TN))\n    TSS_k = np.array(these_TSS_for_this_k)\n    array_of_avg_TSS[k-2] = np.mean(TSS_k)\n    array_of_std_TSS[k-2] = np.std(TSS_k)\n\n\n# Now we can plot the mean TSS per k, using the standard deviation as the error in the TSS. We see that for high values of k, the standard deviation in the TSS can be greater than the mean. These points are indicated in blue.\n\n# In[32]:\n\n\nfig, ax = plt.subplots(figsize=(10, 8))      # define the size of the figure\norangered = (1.0, 0.27, 0, 1.0)              # create an orange-red color\ncornblue = (0.39, 0.58, 0.93, 1.0)           # create a cornflower-blue color\n\n# define some style elements\nmarker_style_red = dict(linestyle='', markersize=8,\n                        fillstyle='full', color=orangered, markeredgecolor=orangered)\nmarker_style_blue = dict(linestyle='', markersize=8,\n                         fillstyle='full', color=cornblue, markeredgecolor=cornblue)\ntext_style = dict(fontsize=16, fontdict={'family': 'monospace'})\n\n# ascribe the data to the axes\nk = np.arange(50)+2\nfor i in range(50):\n    if (array_of_avg_TSS[i] > array_of_std_TSS[i]):\n        ax.errorbar(k[i], array_of_avg_TSS[i],\n                    yerr=array_of_std_TSS[i], linestyle='', color=orangered)\n        ax.plot(k[i], array_of_avg_TSS[i], 'o', **marker_style_red)\n    if (array_of_avg_TSS[i] <= array_of_std_TSS[i]):\n        ax.errorbar(k[i], array_of_avg_TSS[i],\n                    yerr=array_of_std_TSS[i], linestyle='', color=cornblue)\n        ax.plot(k[i], array_of_avg_TSS[i], 'o', **marker_style_blue)\n\n# set plot limits\nplt.xlim(xmax=52, xmin=0)\nplt.ylim(ymax=1.1, ymin=0)\n\n# label the axes and the plot\nax.set_xlabel('k', **text_style)\nax.set_ylabel('TSS', labelpad=20, **text_style)\nplt.title(r'TSS per k using stratified k-fold cross-validation', **text_style)\nfig = plt.gcf()\nfig.set_size_inches(10, 5)\n\n\n# As such, we confirm that high k-values result in a high variance. We find it reasonable to use the stratified 10-fold cross-validation method to compute the TSS and will follow this recommendation. Therefore we report this score as our final result:\n\n# In[33]:\n\n\nprint(\"The TSS equals\", array_of_avg_TSS[9],\n      \"plus or minus\", array_of_std_TSS[9], \".\")\n\n\n# ## Addendum : Local Interpretable Model-Agnostic Explanations (LIME)\n\n# Machine-learning is a powerful technique that can help us predict CMEs. However, our goal is not only to predict CMEs, but also to quantitatively understand which signatures indicate the imminent eruption of a CME. But the practical successes of machine-learning algorithms are often not matched by successes in understanding, and this has become an issue within the machine-learning community ([Rahimi and Recht, 2017](http://www.argmin.net/2017/12/11/alchemy-addendum/)).\n# \n# The SVM is a good model to start with, because it is (relatively) simple and we can use the Univariate Fisher Score to identify the most predictive features. But it would also be useful to figure out why each individual active region was classed as positive or negative. To do this, we can use a tool called [LIME](https://github.com/marcotcr/lime) (or Local Interpretable Model-Agnostic Explanations). <br>\n# \n# First, we initialize the LIME explainer:\n\n# In[34]:\n\n\nexplainer = lime.lime_tabular.LimeTabularExplainer(\n    xtrain, feature_names=sharps, class_names=['CME', 'no CME'], discretize_continuous=True)\n\n\n# Then we use the explainer to explain its choice for a particular active region. To do this, the LIME module generates neighborhood data by randomly perturbing the values of the features associated with this active region. If, for any given feature, this perturbation does not change the outcome of the prediction, this feature isn't useful along the perturbed dimension. If, for any given feature, the perturbation does change the outcome of the prediction, this feature is useful along the perturbed dimension. Thus the explainer can determine which features are useful under which conditions.\n\n# In[35]:\n\n\ni = np.random.randint(0, xtest.shape[0])\nexp = explainer.explain_instance(xtest[i], clf.predict_proba, num_features=8)\n\n\n# Now we can visualize the results. The bottom left panel shows the probabilities assigned to this particular example (which are computed by the SVM via the `probability=True` parameter). The right panel plots the weights per feature (and indicates the values of these weights at the end of each horizontal bar). The text describes the conditions under which this feature  is predictive. \n\n# In[36]:\n\n\nprint(\"Here is the prediction explanation for NOAA Active Region\",\n      mtest[i][1], \"(HARPNUM \", mtest[i][0], \"),\\n which produced a\", mtest[i][2], \"class flare on\", mtest[i][3], \".\")\nexp.show_in_notebook(show_table=False, show_all=False)\n\n\n# Here is the same information in words:\n\n# In[37]:\n\n\nexplained_list = exp.as_list()\nfor i in range(len(explained_list)):\n    if (explained_list[i][1]) < 0:\n        feature_sign = 'no CME'\n    else:\n        feature_sign = 'CME'\n    print(\"The following condition:\", explained_list[i][0], \"\\n predicts\",\n          feature_sign, \"with a model weight of\", abs(explained_list[i][1]), \".\")\n\n", "meta": {"hexsha": "c5aa6f5e4941febfd335baa8bd0a4b26c547d87b", "size": 36931, "ext": "py", "lang": "Python", "max_stars_repo_path": "book/_build/jupyter_execute/02/notebook.py", "max_stars_repo_name": "tbloch1/HelioML", "max_stars_repo_head_hexsha": "ae308b1881bfd08d9dd7add53d304446423a3342", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "book/_build/jupyter_execute/02/notebook.py", "max_issues_repo_name": "tbloch1/HelioML", "max_issues_repo_head_hexsha": "ae308b1881bfd08d9dd7add53d304446423a3342", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "book/_build/jupyter_execute/02/notebook.py", "max_forks_repo_name": "tbloch1/HelioML", "max_forks_repo_head_hexsha": "ae308b1881bfd08d9dd7add53d304446423a3342", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.6501854141, "max_line_length": 878, "alphanum_fraction": 0.7117056132, "include": true, "reason": "import numpy,import scipy", "num_tokens": 9419, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.38491214448393346, "lm_q2_score": 0.14223188773801163, "lm_q1q2_score": 0.054746780923236135}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Dirichlet Distribution\n\n# In[260]:\n\n\n\n\n\n# In[261]:\n\n\n\n\n\n# In[262]:\n\n\n\n\n\n# In[1]:\n\n\nfrom IPython.display import  HTML\n\ndef load_d3_in_cell_output():\n  display(HTML(\"<script src='https://d3js.org/d3.v6.min.js'></script>\"))\nget_ipython().events.register('pre_run_cell', load_d3_in_cell_output)\n\n\n# ## The Chinese Restaurant Process\n\n# In the thought problem, we will be examing a situation where a hungery person (🤔) enters a restrauant and needs to choose a table (⚪).\n# \n# This original was developed by xxx and a great resource to consider is Pasupat's (xxx).\n# \n# Here are the ground rules for this thought problem.\n#   \n\n# ## Rules for Our Thought Problem\n\n# ### 1. An Infinite Amount of Tables (⚪)\n# \n# We are depicting five tables (⚪⚪⚪⚪⚪) but we need to consider a situation where the number of tables are infinite. \n# \n# * ⚪ = ∞\n\n# ### 2. A Hungry Person (🤔) Only Two Options\n# \n# When a hungry person (🤔) walks into the the restraunt they have two options: \n#     \n# * Either they sit a table (⚪) with someone else (😃) \n# * or pick a new table  (⚪) \n# \n# To simplify this, here a decision chart. \n\n# In[2]:\n\n\nfrom IPython.display import SVG, display\ndisplay(SVG(url='https://raw.githubusercontent.com/dudaspm/LDA_Bias_Data/main/images/startCondition.svg'))\n\n\n# And to further reduce this down, we will be using this:\n\n# In[3]:\n\n\nfrom IPython.display import SVG, display\ndisplay(SVG(url='https://raw.githubusercontent.com/dudaspm/LDA_Bias_Data/main/images/simpleStartCondition.svg'))\n\n\n# ### 3. Many ⚪ & 😃, Only One Empty ⚪\n# \n# This goes with #2, but in our scenario there will number of tables (⚪) with people (😃), but when considering an empty table (⚪). We will only consider *one* of the infinite number of tables (⚪) open. Another way to consider this is either a hungry person (🤔):\n# * sits at the *one of possible many* tables (⚪) with someone else (😃) \n# * *OR* they sit at the *one* new table  (⚪)\n\n# ### All Tables (⚪) are Equal\n# Notice that all the tables are equal distance away. So, there is no weighting based on the distance and each table is equally likely to be picked.     \n\n# In[4]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"runWeight()\" value=\"Run Animation\">\\n<div id=\"runWeight\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function runWeight() {\\n        var width = 500\\n        var height = 270\\n        var margin = 35\\n        var radius = 200\\n        \\n        d3.select(\"div#runWeight\").select(\"svg\").remove()\\n        var svg1 = d3.select(\"div#runWeight\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n\\n        svg1.selectAll(\"line\")\\n            .data(d3.range(5))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg1.selectAll(\"circle\")\\n            // Collect\\n            .data(d3.range(5))\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", \"white\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        svg1.append(\"text\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n    }\\n    runWeight()\\n</script>')\n\n\n# ### Key for Thought Problem\n# \n# > 🤔 - hungry person\n# * The person who needs to find a seat at a table\n# \n# > 😃 - person eating\n# * A person already at a table\n# \n# > ⚪ - a possible table\n# * A potential seat for the hungry person to sit at\n# \n# > ⚫ - a not possible table \n# * Not a potential seat for the hungry person to sit at (see Rule #3)\n\n# ## All Solutions 💥TO THE EXTREME💥\n\n# :::{note}\n# \"To the extreme!\" was a popular phrase from the early 1990s. Meaning \"to take something to its furthest limits.\" Most credit [Robert Matthew Van Winkle](https://en.wikipedia.org/wiki/Vanilla_Ice) for the phrase. \n# :::\n\n# Now that we have our ground rules, let's approach this problem from, what I am calling, the extreme positions. Up to this point, we have not mentioned a single bit of math, but this section will contain conversations around probabilities. Here are three scenarios for our extreme positions. \n# \n# 1. The Social Butterfly\n# 2. The Gambler\n# 3. The Long Day\n\n# ### 1. The Social Butterfly\n# \n# The social butterfly assumes every person that enters the restraunts wants to sit at the table with the most people. \n\n# In[5]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"social1()\" value=\"Run Animation\">\\n<div id=\"social1\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function social1() {\\n        var width = 500\\n        var height = 270\\n        var margin = 35\\n        var radius = 200\\n        \\n        d3.select(\"div#social1\").select(\"svg\").remove()\\n        var svg2 = d3.select(\"div#social1\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n\\n        svg2.selectAll(\"line\")\\n            .data(d3.range(1))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg2.selectAll(\"circle\")\\n            // Collect\\n            .data(d3.range(5))\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (i<=0)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        fractions = [\"1\",\"0\",\"0\",\"0\",\"0\"]\\n        svg2.selectAll(\"text\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg2.append(\"text\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n    }\\n    social1()\\n</script>')\n\n\n# In[6]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"social2()\" value=\"Run Animation\">\\n<div id=\"social2\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function social2() {\\n        var width = 600\\n        var height = 300\\n        var margin = 55\\n        var radius = 200\\n        \\n        d3.select(\"div#social2\").select(\"svg\").remove()\\n        var svg3 = d3.select(\"div#social2\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n\\n        svg3.selectAll(\"line\")\\n            .data(d3.range(2))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg3.selectAll(\"circle\")\\n            // Collect\\n            .data(d3.range(5))\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (i<=1)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        fractions = [\"1/1\",\"0\",\"0\",\"0\",\"0\"]\\n        svg3.selectAll(\"text.perc\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg3.append(\"text\")\\n            .attr(\"class\",\"hungry\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n        \\n        function addPeople(cx,cy,e,s) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed\")\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed\")\\n                .attr(\"x\", cx)\\n                .attr(\"y\", cy)  \\n                .style(\"font-size\",\"30px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>\"😃\")\\n                .transition(\"text2\")\\n                .duration(1000)\\n                .delay((d,i)=> i * 100)\\n                .attr(\"x\", (d,i)=> ((40) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((40) * Math.sin(xc(i))) + cy)\\n        \\n            \\n        }\\n        var cx = ((radius) * Math.cos(x(0))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(0))) + (height-margin)\\n        addPeople(cx,cy,1,svg3)\\n    }\\n    social2()\\n</script>')\n\n\n# In[7]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"social3()\" value=\"Run Animation\">\\n<div id=\"social3\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function social3() {\\n        var width = 600\\n        var height = 300\\n        var margin = 55\\n        var radius = 200\\n        \\n        d3.select(\"div#social3\").select(\"svg\").remove()\\n        var svg4 = d3.select(\"div#social3\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n\\n        svg4.selectAll(\"line\")\\n            .data(d3.range(2))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg4.selectAll(\"circle\")\\n            // Collect\\n            .data(d3.range(5))\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (i<=1)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        fractions = [\"2/2\",\"0\",\"0\",\"0\",\"0\"]\\n        svg4.selectAll(\"text.perc\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg4.append(\"text\")\\n            .attr(\"class\",\"hungry\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n        \\n        function addPeople(cx,cy,e,s) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed\")\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed\")\\n                .attr(\"x\", cx)\\n                .attr(\"y\", cy)  \\n                .style(\"font-size\",\"30px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>\"😃\")\\n                .transition(\"text2\")\\n                .duration(1000)\\n                .delay((d,i)=> i * 100)\\n                .attr(\"x\", (d,i)=> ((40) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((40) * Math.sin(xc(i))) + cy)\\n        \\n            \\n        }\\n        var cx = ((radius) * Math.cos(x(0))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(0))) + (height-margin)\\n        addPeople(cx,cy,2,svg4)\\n    }\\n    social3()\\n</script>')\n\n\n# In[8]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"social4()\" value=\"Run Animation\">\\n<div id=\"social4\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function social4() {\\n        var width = 600\\n        var height = 300\\n        var margin = 55\\n        var radius = 200\\n        \\n        d3.select(\"div#social4\").select(\"svg\").remove()\\n        var svg5 = d3.select(\"div#social4\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n\\n        svg5.selectAll(\"line\")\\n            .data(d3.range(2))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg5.selectAll(\"circle\")\\n            // Collect\\n            .data(d3.range(5))\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (i<=1)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        fractions = [\"3/3\",\"0\",\"0\",\"0\",\"0\"]\\n        svg5.selectAll(\"text.perc\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg5.append(\"text\")\\n            .attr(\"class\",\"hungry\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n        \\n        function addPeople(cx,cy,e,s) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed\")\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed\")\\n                .attr(\"x\", cx)\\n                .attr(\"y\", cy)  \\n                .style(\"font-size\",\"30px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>\"😃\")\\n                .transition(\"text2\")\\n                .duration(1000)\\n                .delay((d,i)=> i * 100)\\n                .attr(\"x\", (d,i)=> ((40) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((40) * Math.sin(xc(i))) + cy)\\n        \\n            \\n        }\\n        var cx = ((radius) * Math.cos(x(0))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(0))) + (height-margin)\\n        addPeople(cx,cy,3,svg5)\\n    }\\n    social4()\\n</script>')\n\n\n# In[9]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"social5()\" value=\"Run Animation\">\\n<div id=\"social5\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function social5() {\\n        var width = 600\\n        var height = 300\\n        var margin = 55\\n        var radius = 200\\n        \\n        d3.select(\"div#social5\").select(\"svg\").remove()\\n        var svg6 = d3.select(\"div#social5\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n\\n        svg6.selectAll(\"line\")\\n            .data(d3.range(2))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg6.selectAll(\"circle\")\\n            // Collect\\n            .data(d3.range(5))\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (i<=1)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        fractions = [\"4/4\",\"0\",\"0\",\"0\",\"0\"]\\n        svg6.selectAll(\"text.perc\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg6.append(\"text\")\\n            .attr(\"class\",\"hungry\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n        \\n        function addPeople(cx,cy,e,s) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed\")\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed\")\\n                .attr(\"x\", cx)\\n                .attr(\"y\", cy)  \\n                .style(\"font-size\",\"30px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>\"😃\")\\n                .transition(\"text2\")\\n                .duration(1000)\\n                .delay((d,i)=> i * 100)\\n                .attr(\"x\", (d,i)=> ((40) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((40) * Math.sin(xc(i))) + cy)\\n        \\n            \\n        }\\n        var cx = ((radius) * Math.cos(x(0))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(0))) + (height-margin)\\n        addPeople(cx,cy,4,svg6)\\n    }\\n    social5()\\n</script>')\n\n\n# ### 2. The Gambler\n# \n# The Gambler is the person who only cares about the probabilites. Meaning, if there is two tables (xx), then they have a 50/50 choice, and they do not care at all about the people sitting there or not. \n\n# In[10]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"gambler1()\" value=\"Run Animation\">\\n<div id=\"gambler1\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function gambler1() {\\n        var width = 500\\n        var height = 270\\n        var margin = 35\\n        var radius = 200\\n        \\n        d3.select(\"div#gambler1\").select(\"svg\").remove()\\n        var svg7 = d3.select(\"div#gambler1\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n\\n        svg7.selectAll(\"line\")\\n            .data(d3.range(1))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg7.selectAll(\"circle\")\\n            // Collect\\n            .data(d3.range(5))\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (i<=0)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        fractions = [\"1/1\",\"0\",\"0\",\"0\",\"0\"]\\n        svg7.selectAll(\"text\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg7.append(\"text\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n    }\\n    gambler1()\\n</script>')\n\n\n# In[11]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"gambler2()\" value=\"Run Animation\">\\n<div id=\"gambler2\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function gambler2() {\\n        var width = 600\\n        var height = 300\\n        var margin = 55\\n        var radius = 200\\n        \\n        d3.select(\"div#gambler2\").select(\"svg\").remove()\\n        var svg8 = d3.select(\"div#gambler2\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n\\n        svg8.selectAll(\"line\")\\n            .data(d3.range(2))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg8.selectAll(\"circle\")\\n            // Collect\\n            .data(d3.range(5))\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (i<=1)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        fractions = [\"1/2\",\"1/2\",\"0\",\"0\",\"0\"]\\n        svg8.selectAll(\"text.perc\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg8.append(\"text\")\\n            .attr(\"class\",\"hungry\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n        \\n        function addPeople(cx,cy,e,s) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed\")\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed\")\\n                .attr(\"x\", cx)\\n                .attr(\"y\", cy)  \\n                .style(\"font-size\",\"30px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>\"😃\")\\n                .transition(\"text2\")\\n                .duration(1000)\\n                .delay((d,i)=> i * 100)\\n                .attr(\"x\", (d,i)=> ((40) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((40) * Math.sin(xc(i))) + cy)\\n        \\n            \\n        }\\n        var cx = ((radius) * Math.cos(x(0))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(0))) + (height-margin)\\n        addPeople(cx,cy,1,svg8)\\n    }\\n    gambler2()\\n</script>')\n\n\n# In[12]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"gambler3()\" value=\"Run Animation\">\\n<div id=\"gambler3\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function gambler3() {\\n        var width = 600\\n        var height = 300\\n        var margin = 55\\n        var radius = 200\\n        \\n        d3.select(\"div#gambler3\").select(\"svg\").remove()\\n        var svg9 = d3.select(\"div#gambler3\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n        fractions = [\"1/3\",\"1/3\",\"1/3\",\"0\",\"0\"]\\n        svg9.selectAll(\"line\")\\n            .data(d3.range(3))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg9.selectAll(\"circle\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (+d!=0)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        \\n        svg9.selectAll(\"text.perc\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg9.append(\"text\")\\n            .attr(\"class\",\"hungry\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n        \\n        function addPeople(cx,cy,e,s,c) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed_\"+c)\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed_\"+c)\\n                .attr(\"x\", cx)\\n                .attr(\"y\", cy)  \\n                .style(\"font-size\",\"30px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>\"😃\")\\n                .transition(\"text2\")\\n                .duration(1000)\\n                .delay((d,i)=> i * 100)\\n                .attr(\"x\", (d,i)=> ((40) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((40) * Math.sin(xc(i))) + cy)\\n        \\n            \\n        }\\n        var cx = ((radius) * Math.cos(x(0))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(0))) + (height-margin)\\n        addPeople(cx,cy,1,svg9,0)\\n        var cx = ((radius) * Math.cos(x(1))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(1))) + (height-margin)\\n        addPeople(cx,cy,1,svg9,1)\\n    }\\n    gambler3()\\n</script>')\n\n\n# In[13]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"gambler4()\" value=\"Run Animation\">\\n<div id=\"gambler4\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function gambler4() {\\n        var width = 600\\n        var height = 300\\n        var margin = 55\\n        var radius = 200\\n        \\n        d3.select(\"div#gambler4\").select(\"svg\").remove()\\n        var svg10 = d3.select(\"div#gambler4\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n        fractions = [\"1/4\",\"1/4\",\"1/4\",\"1/4\",\"0\"]\\n        svg10.selectAll(\"line\")\\n            .data(d3.range(4))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg10.selectAll(\"circle\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (+d!=0)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        \\n        svg10.selectAll(\"text.perc\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg10.append(\"text\")\\n            .attr(\"class\",\"hungry\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n        \\n        function addPeople(cx,cy,e,s,c) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed_\"+c)\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed_\"+c)\\n                .attr(\"x\", cx)\\n                .attr(\"y\", cy)  \\n                .style(\"font-size\",\"30px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>\"😃\")\\n                .transition(\"text2\")\\n                .duration(1000)\\n                .delay((d,i)=> i * 100)\\n                .attr(\"x\", (d,i)=> ((40) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((40) * Math.sin(xc(i))) + cy)\\n        \\n            \\n        }\\n        var cx = ((radius) * Math.cos(x(0))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(0))) + (height-margin)\\n        addPeople(cx,cy,1,svg10,0)\\n        var cx = ((radius) * Math.cos(x(1))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(1))) + (height-margin)\\n        addPeople(cx,cy,1,svg10,1)\\n        var cx = ((radius) * Math.cos(x(2))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(2))) + (height-margin)\\n        addPeople(cx,cy,1,svg10,2)\\n    }\\n    gambler4()\\n</script>')\n\n\n# In[14]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"gambler5()\" value=\"Run Animation\">\\n<div id=\"gambler5\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function gambler5() {\\n        var width = 600\\n        var height = 300\\n        var margin = 55\\n        var radius = 200\\n        \\n        d3.select(\"div#gambler5\").select(\"svg\").remove()\\n        var svg11 = d3.select(\"div#gambler5\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n        fractions = [\"1/5\",\"1/5\",\"1/5\",\"1/5\",\"1/5\"]\\n        svg11.selectAll(\"line\")\\n            .data(d3.range(5))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg11.selectAll(\"circle\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (+d!=0)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        \\n        svg11.selectAll(\"text.perc\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg11.append(\"text\")\\n            .attr(\"class\",\"hungry\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n        \\n        function addPeople(cx,cy,e,s,c) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed_\"+c)\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed_\"+c)\\n                .attr(\"x\", cx)\\n                .attr(\"y\", cy)  \\n                .style(\"font-size\",\"30px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>\"😃\")\\n                .transition(\"text2\")\\n                .duration(1000)\\n                .delay((d,i)=> i * 100)\\n                .attr(\"x\", (d,i)=> ((40) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((40) * Math.sin(xc(i))) + cy)\\n        \\n            \\n        }\\n        var cx = ((radius) * Math.cos(x(0))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(0))) + (height-margin)\\n        addPeople(cx,cy,1,svg11,0)\\n        var cx = ((radius) * Math.cos(x(1))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(1))) + (height-margin)\\n        addPeople(cx,cy,1,svg11,1)\\n        var cx = ((radius) * Math.cos(x(2))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(2))) + (height-margin)\\n        addPeople(cx,cy,1,svg11,2)\\n        var cx = ((radius) * Math.cos(x(3))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(3))) + (height-margin)\\n        addPeople(cx,cy,1,svg11,3)\\n    }\\n    gambler5()\\n</script>')\n\n\n# ### 3. The Long Day\n# \n# The Long Day scenerio describes a situation where customers (xx) coming into the restraunt had a reeeeeeeeeeeeeeeally long day. All they want is a table (xx) to themselves to eat their food, pay, and go home. This is the opposite of the Social Butterfly, where if there are people at a table (😃 & xx). They will find an empty table (xxx).\n# \n\n# In[15]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"long1()\" value=\"Run Animation\">\\n<div id=\"long1\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function long1() {\\n        var width = 500\\n        var height = 270\\n        var margin = 35\\n        var radius = 200\\n        \\n        d3.select(\"div#long1\").select(\"svg\").remove()\\n        var svg12 = d3.select(\"div#long1\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n\\n        svg12.selectAll(\"line\")\\n            .data(d3.range(1))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg12.selectAll(\"circle\")\\n            // Collect\\n            .data(d3.range(5))\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (i<=0)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        fractions = [\"1/1\",\"0\",\"0\",\"0\",\"0\"]\\n        svg12.selectAll(\"text\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg12.append(\"text\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n    }\\n    long1()\\n</script>')\n\n\n# In[16]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"long2()\" value=\"Run Animation\">\\n<div id=\"long2\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function long2() {\\n        var width = 600\\n        var height = 300\\n        var margin = 55\\n        var radius = 200\\n        \\n        d3.select(\"div#long2\").select(\"svg\").remove()\\n        var svg13 = d3.select(\"div#long2\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n\\n        svg13.selectAll(\"line\")\\n            .data(d3.range(2))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg13.selectAll(\"circle\")\\n            // Collect\\n            .data(d3.range(5))\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (i<=1)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        fractions = [\"0\",\"1/1\",\"0\",\"0\",\"0\"]\\n        svg13.selectAll(\"text.perc\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg13.append(\"text\")\\n            .attr(\"class\",\"hungry\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n        \\n        function addPeople(cx,cy,e,s,c) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed_\"+c)\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed_\"+c)\\n                .attr(\"x\", cx)\\n                .attr(\"y\", cy)  \\n                .style(\"font-size\",\"30px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>\"😃\")\\n                .transition(\"text2\")\\n                .duration(1000)\\n                .delay((d,i)=> i * 100)\\n                .attr(\"x\", (d,i)=> ((40) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((40) * Math.sin(xc(i))) + cy)\\n        \\n            \\n        }\\n        var cx = ((radius) * Math.cos(x(0))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(0))) + (height-margin)\\n        addPeople(cx,cy,1,svg13,0)\\n\\n    }\\n    long2()\\n</script>')\n\n\n# In[17]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"long3()\" value=\"Run Animation\">\\n<div id=\"long3\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function long3() {\\n        var width = 600\\n        var height = 300\\n        var margin = 55\\n        var radius = 200\\n        \\n        d3.select(\"div#long3\").select(\"svg\").remove()\\n        var svg14 = d3.select(\"div#long3\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n\\n        svg14.selectAll(\"line\")\\n            .data(d3.range(3))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg14.selectAll(\"circle\")\\n            // Collect\\n            .data(d3.range(5))\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (i<=2)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        fractions = [\"0\",\"0\",\"2/2\",\"0\",\"0\"]\\n        svg14.selectAll(\"text.perc\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg14.append(\"text\")\\n            .attr(\"class\",\"hungry\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n        \\n        function addPeople(cx,cy,e,s,c) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed_\"+c)\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed_\"+c)\\n                .attr(\"x\", cx)\\n                .attr(\"y\", cy)  \\n                .style(\"font-size\",\"30px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>\"😃\")\\n                .transition(\"text2\")\\n                .duration(1000)\\n                .delay((d,i)=> i * 100)\\n                .attr(\"x\", (d,i)=> ((40) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((40) * Math.sin(xc(i))) + cy)\\n        \\n            \\n        }\\n        var cx = ((radius) * Math.cos(x(0))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(0))) + (height-margin)\\n        addPeople(cx,cy,1,svg14,0)\\n        var cx = ((radius) * Math.cos(x(1))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(1))) + (height-margin)\\n        addPeople(cx,cy,1,svg14,1)\\n\\n    }\\n    long3()\\n</script>')\n\n\n# In[18]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"long4()\" value=\"Run Animation\">\\n<div id=\"long4\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function long4() {\\n        var width = 600\\n        var height = 300\\n        var margin = 55\\n        var radius = 200\\n        \\n        d3.select(\"div#long4\").select(\"svg\").remove()\\n        var svg15 = d3.select(\"div#long4\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n\\n        svg15.selectAll(\"line\")\\n            .data(d3.range(4))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg15.selectAll(\"circle\")\\n            // Collect\\n            .data(d3.range(5))\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (i<=3)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        fractions = [\"0\",\"0\",\"0\",\"1\",\"0\"]\\n        svg15.selectAll(\"text.perc\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg15.append(\"text\")\\n            .attr(\"class\",\"hungry\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n        \\n        function addPeople(cx,cy,e,s,c) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed_\"+c)\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed_\"+c)\\n                .attr(\"x\", cx)\\n                .attr(\"y\", cy)  \\n                .style(\"font-size\",\"30px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>\"😃\")\\n                .transition(\"text2\")\\n                .duration(1000)\\n                .delay((d,i)=> i * 100)\\n                .attr(\"x\", (d,i)=> ((40) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((40) * Math.sin(xc(i))) + cy)\\n        \\n            \\n        }\\n        var cx = ((radius) * Math.cos(x(0))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(0))) + (height-margin)\\n        addPeople(cx,cy,1,svg15,0)\\n        var cx = ((radius) * Math.cos(x(1))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(1))) + (height-margin)\\n        addPeople(cx,cy,1,svg15,1)\\n        var cx = ((radius) * Math.cos(x(2))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(2))) + (height-margin)\\n        addPeople(cx,cy,1,svg15,2)\\n\\n    }\\n    long4()\\n</script>')\n\n\n# In[19]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" onclick=\"long5()\" value=\"Run Animation\">\\n<div id=\"long5\"></div>\\n\\n<script type=\"text/javascript\">   \\n    function long5() {\\n        var width = 600\\n        var height = 300\\n        var margin = 55\\n        var radius = 200\\n        \\n        d3.select(\"div#long5\").select(\"svg\").remove()\\n        var svg16 = d3.select(\"div#long5\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        var x = d3.scaleLinear().domain([0,d3.range(5).length-1]).range([Math.PI, 2*Math.PI])\\n\\n        svg16.selectAll(\"line\")\\n            .data(d3.range(5))\\n            .join(\"line\")\\n            .attr(\"x1\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y1\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"x2\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin)) \\n            .style(\"stroke\",\"darkgrey\")\\n            .style(\"stroke-width\", \"10px\")\\n            .style(\"stroke-linecap\",\"round\")\\n            .transition(\"line\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x2\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y2\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))    \\n\\n        svg16.selectAll(\"circle\")\\n            // Collect\\n            .data(d3.range(5))\\n            // Update\\n            .join(\"circle\")\\n            .attr(\"cx\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .attr(\"r\", (d,i)=> 30)\\n            .style(\"fill\", (d,i)=> (i<=4)?\"white\":\"black\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            .transition(\"circle\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"cx\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"cy\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n\\n        fractions = [\"0\",\"0\",\"0\",\"0\",\"1\"]\\n        svg16.selectAll(\"text.perc\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc\")\\n            .attr(\"x\", (d,i)=> ((0) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((0) * Math.sin(x(i))) + (height-margin))  \\n            .style(\"font-size\",\"30px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n            .transition(\"text\")\\n            .duration(1000)\\n            .delay((d,i)=> i * 100)\\n            .attr(\"x\", (d,i)=> ((radius) * Math.cos(x(i))) + (width/2))\\n            .attr(\"y\", (d,i)=> ((radius) * Math.sin(x(i))) + (height-margin))\\n        \\n        \\n        \\n        svg16.append(\"text\")\\n            .attr(\"class\",\"hungry\")\\n            .attr(\"x\", width/2)\\n            .attr(\"y\", (height-margin))\\n            .style(\"font-size\",\"50px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"🤔\")\\n        \\n        function addPeople(cx,cy,e,s,c) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed_\"+c)\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed_\"+c)\\n                .attr(\"x\", cx)\\n                .attr(\"y\", cy)  \\n                .style(\"font-size\",\"30px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>\"😃\")\\n                .transition(\"text2\")\\n                .duration(1000)\\n                .delay((d,i)=> i * 100)\\n                .attr(\"x\", (d,i)=> ((40) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((40) * Math.sin(xc(i))) + cy)\\n        \\n            \\n        }\\n        var cx = ((radius) * Math.cos(x(0))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(0))) + (height-margin)\\n        addPeople(cx,cy,1,svg16,0)\\n        var cx = ((radius) * Math.cos(x(1))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(1))) + (height-margin)\\n        addPeople(cx,cy,1,svg16,1)\\n        var cx = ((radius) * Math.cos(x(2))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(2))) + (height-margin)\\n        addPeople(cx,cy,1,svg16,2)\\n        var cx = ((radius) * Math.cos(x(3))) + (width/2)\\n        var cy = ((radius) * Math.sin(x(3))) + (height-margin)\\n        addPeople(cx,cy,1,svg16,3)\\n\\n    }\\n    long5()\\n</script>')\n\n\n# In[ ]:\n\n\n\n\n\n# ## The Conclusions\n# \n# ### ✨1st Conclusion✨\n# \n# So, let's take a look at all three of these scenario results.\n\n# In[20]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" value=\"✨1st Conclusion✨\" style=\"font-size:20px\" onclick=\"conclusion1()\">\\n<div id=\"conc\"></div>\\n\\n<script type=\"text/javascript\">   \\n    var svg17, x, y\\n    function conclusion1() {\\n        var equation = [\"+\",\"+\",\"+\",\"+\",\"= 1\"]\\n        d3.range(3).forEach((d,row)=>{\\n            svg17.selectAll(\"text.equ_\"+row)\\n                // Collect\\n                .data(equation)\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"equ_\"+row)\\n                .attr(\"x\", 0)\\n                .attr(\"y\", y(row))  \\n                .style(\"font-size\",\"20px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>d) \\n                .transition(\"text2\")\\n                .duration(1000)\\n                .delay((d,i)=> (5-i) * 100)\\n                .attr(\"x\", (d,i)=> (i==4) ? (x(i+1)) : (x(i)+x(i+1))/2)\\n            \\n        })\\n\\n\\n    }\\n    function conc() {\\n        var width = 600\\n        var height = 400\\n        var margin = 65\\n        var radius = 200\\n        \\n        d3.select(\"div#conc\").select(\"svg\").remove()\\n        svg17 = d3.select(\"div#conc\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        x = d3.scaleLinear().range([margin,width-margin]).domain([0,6])\\n        y = d3.scaleLinear().range([margin,height-margin]).domain([0,2])\\n        \\n        fractions = [\"1\",\"0\",\"0\",\"0\",\"0\"]\\n        svg17.selectAll(\"circle.row1\")\\n            .data(fractions)\\n            .join(\"circle\")\\n            .attr(\"class\",\"row1\")\\n            .attr(\"cx\", (d,i)=> x(i))\\n            .attr(\"cy\", y(0))  \\n            .attr(\"r\", 20)\\n            .style(\"fill\", \"white\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n            \\n        svg17.selectAll(\"text.perc1\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc1\")\\n            .attr(\"x\", (d,i)=> x(i))\\n            .attr(\"y\", y(0))  \\n            .style(\"font-size\",\"20px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n\\n        \\n        fractions = [\"1/5\",\"1/5\",\"1/5\",\"1/5\",\"1/5\"]\\n        svg17.selectAll(\"circle.row2\")\\n            .data(fractions)\\n            .join(\"circle\")\\n            .attr(\"class\",\"row2\")\\n            .attr(\"cx\", (d,i)=> x(i))\\n            .attr(\"cy\", y(1))  \\n            .attr(\"r\", 20)\\n            .style(\"fill\", \"white\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n\\n        svg17.selectAll(\"text.perc2\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc2\")\\n            .attr(\"x\", (d,i)=> x(i))\\n            .attr(\"y\", y(1))  \\n            .style(\"font-size\",\"20px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n\\n        \\n        fractions = [\"0\",\"0\",\"0\",\"0\",\"1\"]\\n        svg17.selectAll(\"circle.row3\")\\n            .data(fractions)\\n            .join(\"circle\")\\n            .attr(\"class\",\"row3\")\\n            .attr(\"cx\", (d,i)=> x(i))\\n            .attr(\"cy\", y(2))  \\n            .attr(\"r\", 20)\\n            .style(\"fill\", \"white\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n\\n        svg17.selectAll(\"text.perc3\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"class\",\"perc3\")\\n            .attr(\"x\", (d,i)=> x(i))\\n            .attr(\"y\", y(2))  \\n            .style(\"font-size\",\"20px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n\\n        \\n        svg17.append(\"text\")\\n            .attr(\"class\",\"title1\")\\n            .attr(\"x\", 20)\\n            .attr(\"y\", y(0)-45)  \\n            .style(\"font-size\",\"20px\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"The Social Butterfly\")     \\n        \\n        svg17.append(\"text\")\\n            .attr(\"class\",\"title1\")\\n            .attr(\"x\", 20)\\n            .attr(\"y\", y(1)-45)  \\n            .style(\"font-size\",\"20px\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"The Gambler\") \\n\\n        svg17.append(\"text\")\\n            .attr(\"class\",\"title1\")\\n            .attr(\"x\", 20)\\n            .attr(\"y\", y(2)-45)  \\n            .style(\"font-size\",\"20px\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"The Long Day\") \\n        \\n        function addPeople(cx,cy,e,s,c) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed_\"+c)\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed_\"+c)\\n                .attr(\"x\", (d,i)=> ((20) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((20) * Math.sin(xc(i))) + cy)\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>\"😃\")\\n\\n        \\n            \\n        }\\n        var cx = x(0)\\n        var cy = y(0)\\n        addPeople(cx,cy,4,svg17,0)\\n        \\n        d3.range(4).forEach((d,i) => {\\n            var cx = x(i)\\n            var cy = y(1)\\n            addPeople(cx,cy,1,svg17,i+1)\\n            \\n        })\\n\\n        var cx = x(4)\\n        var cy = y(2)\\n        addPeople(cx,cy,4,svg17,6)\\n\\n\\n    }\\n    conc()\\n</script>')\n\n\n# Our ✨1st Conclusion✨ is that for each scenerio, the total probablities (when added together), equal 1. This is our first connection the *Dirichlet Distribution*. \n\n# ```{admonition} Dirichlet Distribution Always Sum to 1\n# :class: tip\n# Regardless of the number of tables (⚪), the number of people at the tables (😃), or a hungry persons' (🤔) strategy. The total probability will be 1. This is also consider to be a *probability mass function* or PMF property. \n# ```\n\n# ### ✨2nd Conclusion✨\n# \n# This easiest to see with our \"The Gambler\" scenerio. \n\n# In[21]:\n\n\nget_ipython().run_cell_magic('html', '', '<input type=\"button\" value=\"✨2nd Conclusion✨\" style=\"font-size:20px\" onclick=\"conclusion2()\">\\n<div id=\"conc2\"></div>\\n\\n<script type=\"text/javascript\">   \\n    var svg18, x, y\\n    var width = 600\\n    var height = 400\\n    var margin = 65\\n    var radius = 200\\n    function conclusion2() {\\n        conc2()\\n        svg18.selectAll(\"circle#face_4\")\\n            .transition(\"move1\")\\n            .duration(1000)\\n            .attr(\"cx\", (d,i)=> x(5))\\n        \\n        svg18.selectAll(\"text#face_4\")\\n            .transition(\"move2\")\\n            .duration(1000)\\n            .attr(\"x\", (d,i)=> x(5))\\n        \\n        svg18.selectAll(\"text#feed_5\")\\n            .transition(\"move2b\")\\n            .duration(1000)\\n            .attr(\"x\", (d,i)=> x(5)-20)\\n        \\n        svg18.append(\"line\")\\n            .attr(\"id\",\"join\")\\n            .attr(\"x1\", (x(3) + x(0))/2)\\n            .attr(\"y1\", (y(1)+y(0))/2)\\n            .attr(\"x2\", (x(3) + x(0))/2)\\n            .attr(\"y2\", (y(1)+y(0))/2)\\n            .style(\"stroke\", \"purple\")\\n            .style(\"stroke-width\", \"3px\")\\n            .transition(\"move3\")\\n            .duration(1000)\\n            .attr(\"x1\", x(0) - 10)\\n            .attr(\"x2\", x(3) + 10)\\n        \\n        svg18.append(\"line\")\\n            .attr(\"id\",\"join\")\\n            .attr(\"x1\", (x(6) + x(4))/2)\\n            .attr(\"y1\", (y(1)+y(0))/2)\\n            .attr(\"x2\", (x(6) + x(4))/2)\\n            .attr(\"y2\", (y(1)+y(0))/2)\\n            .style(\"stroke\", \"steelblue\")\\n            .style(\"stroke-width\", \"3px\")\\n            .transition(\"move4\")\\n            .duration(1000)\\n            .attr(\"x1\", x(4) - 10)\\n            .attr(\"x2\", x(6) + 10)\\n        \\n        svg18.append(\"text\")\\n            .attr(\"id\",\"join\")\\n            .attr(\"x\", (d,i)=> - 10)\\n            .attr(\"y\", y(1))  \\n            .style(\"font-size\",\"20px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"To Join\")\\n            .transition(\"move5\")\\n            .duration(1000)\\n            .attr(\"x\", (x(3) + x(0))/2) \\n        \\n        svg18.append(\"text\")\\n            .attr(\"id\",\"join\")\\n            .attr(\"x\", (d,i)=> width + 10)\\n            .attr(\"y\", y(1))  \\n            .style(\"font-size\",\"20px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"Or Not To Join\")\\n            .transition(\"move6\")\\n            .duration(1000)\\n            .attr(\"x\", (x(6) + x(4))/2) \\n        \\n        svg18.append(\"text\")\\n            .attr(\"id\",\"join\")\\n            .attr(\"x\", (d,i)=> ((x(4) - 10)+(x(3) + 10))/2)\\n            .attr(\"y\", -10)  \\n            .style(\"font-size\",\"20px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"+\")\\n            .transition(\"move6\")\\n            .duration(1000)\\n            .attr(\"y\", (y(1)+y(0))/2)\\n        \\n        \\n        function createEquation1(cx,cy,top) {\\n            svg18.append(\"text\")\\n                .attr(\"x\", cx)\\n                .attr(\"y\", height+10)  \\n                .style(\"font-size\",\"20px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(top)\\n                .transition(\"move6\")\\n                .duration(1000)\\n                .attr(\"y\", y(2)-15)\\n            \\n            svg18.append(\"line\")\\n                .attr(\"x1\", cx)\\n                .attr(\"y1\", 0)  \\n                .attr(\"x2\", cx)\\n                .attr(\"y2\", 0)\\n                .style(\"stroke\", (top == \"🤔\") ? \"steelblue\" : \"purple\")\\n                .style(\"stroke-width\", \"3px\")\\n                .transition(\"move7\")\\n                .duration(1000)\\n                .attr(\"y1\", cy)\\n                .attr(\"y2\", cy)\\n                .transition(\"move8\")\\n                .duration(1000)\\n                .attr(\"x1\", cx-20)\\n                .attr(\"x2\", cx+20)\\n            \\n            svg18.append(\"text\")\\n                .attr(\"x\", cx)\\n                .attr(\"y\", height+10)  \\n                .style(\"font-size\",\"10px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(\"😃😃😃😃🤔\")\\n                .transition(\"move8\")\\n                .duration(1000)\\n                .attr(\"y\", y(2)+15)\\n            \\n        }\\n        function createEquation2(cx,top) {\\n            svg18.append(\"text\")\\n                .attr(\"x\", cx)\\n                .attr(\"y\", height+10)  \\n                .style(\"font-size\",(top==\"= 1\") ? \"30px\" : \"20px\")\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(top)\\n                .transition(\"move6\")\\n                .duration(1000)\\n                .attr(\"y\", y(2))\\n\\n        }\\n        createEquation1(x(0),y(2),\"😃\")\\n        createEquation2((x(0)+x(1))/2,\"+\")\\n        \\n        createEquation1(x(1),y(2),\"😃\")\\n        createEquation2((x(1)+x(2))/2,\"+\")        \\n        \\n        createEquation1(x(2),y(2),\"😃\")\\n        createEquation2((x(2)+x(3))/2,\"+\")\\n        \\n        createEquation1(x(3),y(2),\"😃\")\\n        createEquation2((x(3)+x(4))/2,\"+\")\\n        \\n        createEquation1(x(5),y(2),\"🤔\")\\n        createEquation2((x(6)),\"= 1\")\\n    }\\n    function conc2() {\\n        \\n        d3.select(\"div#conc2\").select(\"svg\").remove()\\n        svg18 = d3.select(\"div#conc2\").append(\"svg\")\\n            .attr(\"width\", width)\\n            .attr(\"height\", height)\\n\\n        x = d3.scaleLinear().range([margin,width-margin]).domain([0,6])\\n        y = d3.scaleLinear().range([margin,height-margin]).domain([0,2])\\n        \\n\\n        \\n        fractions = [\"1/5\",\"1/5\",\"1/5\",\"1/5\",\"1/5\"]\\n        svg18.selectAll(\"circle.row2\")\\n            .data(fractions)\\n            .join(\"circle\")\\n            .attr(\"id\",(d,i)=> \"face_\"+i)\\n            .attr(\"class\",\"row2\")\\n            .attr(\"cx\", (d,i)=> x(i))\\n            .attr(\"cy\", y(0))  \\n            .attr(\"r\", 20)\\n            .style(\"fill\", \"white\")\\n            .style(\"stroke\", \"black\")\\n            .style(\"stroke-width\", \"1px\")\\n\\n        svg18.selectAll(\"text.perc2\")\\n            // Collect\\n            .data(fractions)\\n            // Update\\n            .join(\"text\")\\n            .attr(\"id\",(d,i)=> \"face_\"+i)\\n            .attr(\"class\",\"perc2\")\\n            .attr(\"x\", (d,i)=> x(i))\\n            .attr(\"y\", y(0))  \\n            .style(\"font-size\",\"20px\")\\n            .style(\"text-anchor\", \"middle\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(d=>d)\\n        \\n        svg18.append(\"text\")\\n            .attr(\"class\",\"title1\")\\n            .attr(\"x\", 20)\\n            .attr(\"y\", y(0)-45)  \\n            .style(\"font-size\",\"20px\")\\n            .style(\"alignment-baseline\",\"middle\")\\n            .text(\"The Gambler - 🤔\") \\n        \\n\\n\\n\\n        \\n        function addPeople(cx,cy,e,s,c) {\\n            var xc = d3.scaleLinear().domain([0,d3.range(e).length]).range([Math.PI, 3*Math.PI])\\n            s.selectAll(\"text.feed_\"+c)\\n                // Collect\\n                .data(d3.range(e))\\n                // Update\\n                .join(\"text\")\\n                .attr(\"class\",\"feed_\"+c)\\n                .attr(\"id\",\"feed_\"+c)\\n                .attr(\"x\", (d,i)=> ((20) * Math.cos(xc(i))) + cx)\\n                .attr(\"y\", (d,i)=> ((20) * Math.sin(xc(i))) + cy)\\n                .style(\"text-anchor\", \"middle\")\\n                .style(\"alignment-baseline\",\"middle\")\\n                .text(d=>(c==5)?\"🤔\":\"😃\")\\n\\n        \\n            \\n        }\\n\\n        \\n        d3.range(5).forEach((d,i) => {\\n            var cx = x(i)\\n            var cy = y(0)\\n            addPeople(cx,cy,1,svg18,i+1)\\n            \\n        })\\n\\n\\n\\n    }\\n    conc2()\\n</script>')\n\n\n# ```{admonition} When All Possibility Are Equally Likely\n# :class: tip\n# In situations where are all possibility are equally likely (equally likely to sit at a table with someone else (⚪&😃) or sit at a new table (⚪)), we can abbreviate this to a simple probablity:\n# \n# $\\frac{😃}{😃😃😃😃}$ $=$ $\\frac{Number of people sitting at table(⚪&😃)}{All people (😃😃😃😃)}$ $= $ $\\frac{Nj}{N}$\n# ```\n\n# In[22]:\n\n\nfrom scipy.stats import dirichlet\nimport numpy as np\n\n\n# In[23]:\n\n\nalpha = np.array([0.01, 0.01, 0.01, 0.01, 0.01])\nnp.around(dirichlet.rvs(alpha, size=5), decimals=1)\n\n\n# In[24]:\n\n\nalpha = np.array([0.1, 0.1, 0.1, 0.1, 0.1])\nnp.around(dirichlet.rvs(alpha, size=5), decimals=1)\n\n\n# In[25]:\n\n\nalpha = np.array([1, 1, 1, 1, 1])\nnp.around(dirichlet.rvs(alpha, size=5), decimals=1)\n\n\n# In[26]:\n\n\nalpha = np.array([5, 5, 5, 5, 5])\nnp.around(dirichlet.rvs(alpha, size=5), decimals=1)\n\n\n# In[27]:\n\n\nalpha = np.array([20, 20, 20, 20, 20])\nnp.around(dirichlet.rvs(alpha, size=5), decimals=1)\n\n\n# In[28]:\n\n\nalpha = np.array([100, 100, 100, 100, 100])\nnp.around(dirichlet.rvs(alpha, size=5), decimals=1)\n\n\n# In[29]:\n\n\nalpha = np.array([0.01, .1, 1, 10, 10])\n\nnp.around(dirichlet.mean(alpha), decimals=3)\n\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "b27050ea010658548da412cae429eac1171d5a41", "size": 84802, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/.~Dirichlet Distribution.py", "max_stars_repo_name": "dudaspm/LDA_Bias_Data", "max_stars_repo_head_hexsha": "ffbabb5765a878bf49bac68baaa083342243a616", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_build/jupyter_execute/.~Dirichlet Distribution.py", "max_issues_repo_name": "dudaspm/LDA_Bias_Data", "max_issues_repo_head_hexsha": "ffbabb5765a878bf49bac68baaa083342243a616", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/.~Dirichlet Distribution.py", "max_forks_repo_name": "dudaspm/LDA_Bias_Data", "max_forks_repo_head_hexsha": "ffbabb5765a878bf49bac68baaa083342243a616", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 261.7345679012, "max_line_length": 7889, "alphanum_fraction": 0.4521001863, "include": true, "reason": "import numpy,from scipy", "num_tokens": 26570, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43782349911420193, "lm_q2_score": 0.12421300024700382, "lm_q1q2_score": 0.054383370403616446}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# In[1]:\n\n\nimport sys, os\nif 'google.colab' in sys.modules and not os.path.exists('.setup_complete'):\n    get_ipython().system('wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/setup_colab.sh -O- | bash')\n\n    get_ipython().system('touch .setup_complete')\n\n# This code creates a virtual display to draw game images on.\n# It will have no effect if your machine has a monitor.\nif type(os.environ.get(\"DISPLAY\")) is not str or len(os.environ.get(\"DISPLAY\")) == 0:\n    get_ipython().system('bash ../xvfb start')\n    os.environ['DISPLAY'] = ':1'\n\n\n# In[2]:\n\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nget_ipython().run_line_magic('matplotlib', 'inline')\n\n\n# ### OpenAI Gym\n# \n# We're gonna spend several next weeks learning algorithms that solve decision processes. We are then in need of some interesting decision problems to test our algorithms.\n# \n# That's where OpenAI Gym comes into play. It's a Python library that wraps many classical decision problems including robot control, videogames and board games.\n# \n# So here's how it works:\n\n# In[3]:\n\n\nimport gym\n\nenv = gym.make(\"MountainCar-v0\")\nenv.reset()\n\nplt.imshow(env.render('rgb_array'))\nprint(\"Observation space:\", env.observation_space)\nprint(\"Action space:\", env.action_space)\n\n\n# Note: if you're running this on your local machine, you'll see a window pop up with the image above. Don't close it, just alt-tab away.\n\n# ### Gym interface\n# \n# The three main methods of an environment are\n# * `reset()`: reset environment to the initial state, _return first observation_\n# * `render()`: show current environment state (a more colorful version :) )\n# * `step(a)`: commit action `a` and return `(new_observation, reward, is_done, info)`\n#  * `new_observation`: an observation right after committing the action `a`\n#  * `reward`: a number representing your reward for committing action `a`\n#  * `is_done`: True if the MDP has just finished, False if still in progress\n#  * `info`: some auxiliary stuff about what just happened. For now, ignore it.\n\n# In[4]:\n\n\nobs0 = env.reset()\nprint(\"initial observation code:\", obs0)\n\n# Note: in MountainCar, observation is just two numbers: car position and velocity\n\n\n# In[5]:\n\n\nprint(\"taking action 2 (right)\")\nnew_obs, reward, is_done, _ = env.step(2)\n\nprint(\"new observation code:\", new_obs)\nprint(\"reward:\", reward)\nprint(\"is game over?:\", is_done)\n\n# Note: as you can see, the car has moved to the right slightly (around 0.0005)\n\n\n# ### Play with it\n# \n# Below is the code that drives the car to the right. However, if you simply use the default policy, the car will not reach the flag at the far right due to gravity.\n# \n# __Your task__ is to fix it. Find a strategy that reaches the flag. \n# \n# You are not required to build any sophisticated algorithms for now, and you definitely don't need to know any reinforcement learning for this. Feel free to hard-code :)\n\n# In[6]:\n\n\nfrom IPython import display\n\n# Create env manually to set time limit. Please don't change this.\nTIME_LIMIT = 250\nenv = gym.wrappers.TimeLimit(\n    gym.envs.classic_control.MountainCarEnv(),\n    max_episode_steps=TIME_LIMIT + 1,\n)\nactions = {'left': 0, 'stop': 1, 'right': 2}\n\n\n# In[7]:\n\n\ndef policy(obs, t):\n    # Write the code for your policy here. You can use the observation\n    # (a tuple of position and velocity), the current time step, or both,\n    # if you want.\n    position, velocity = obs\n    \n    VELOCITY_THRESHOLD = 1e-3\n    if velocity >= VELOCITY_THRESHOLD or velocity < 0 and velocity > -VELOCITY_THRESHOLD:\n        return actions['right']\n    if velocity <= -VELOCITY_THRESHOLD or velocity > 0 and velocity < VELOCITY_THRESHOLD:\n        return actions['left']\n    \n    return actions['right']\n\n\n# In[8]:\n\n\nplt.figure(figsize=(4, 3))\ndisplay.clear_output(wait=True)\n\nobs = env.reset()\nfor t in range(TIME_LIMIT):\n    plt.gca().clear()\n    \n    action = policy(obs, t)  # Call your policy\n    obs, reward, done, _ = env.step(action)  # Pass the action chosen by the policy to the environment\n    \n    # We don't do anything with reward here because MountainCar is a very simple environment,\n    # and reward is a constant -1. Therefore, your goal is to end the episode as quickly as possible.\n\n    # Draw game image on display.\n    plt.imshow(env.render('rgb_array'))\n    plt.title(obs)\n    \n    display.display(plt.gcf())\n    display.clear_output(wait=True)\n\n    if done:\n        print(\"Well done!\")\n        break\nelse:\n    print(\"Time limit exceeded. Try again.\")\n\ndisplay.clear_output(wait=True)\n\n\n# In[10]:\n\n\nassert obs[0] > 0.47\nprint(\"You solved it!\")\n\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "9778c41006f79343804ab53b88ce39060d3b4582", "size": 4643, "ext": "py", "lang": "Python", "max_stars_repo_path": "week01_intro/seminar_gym_interface.py", "max_stars_repo_name": "mikita-zhuryk/Practical_RL", "max_stars_repo_head_hexsha": "4726da9d471f9a4f59f745a009796c2fbbe86e58", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "week01_intro/seminar_gym_interface.py", "max_issues_repo_name": "mikita-zhuryk/Practical_RL", "max_issues_repo_head_hexsha": "4726da9d471f9a4f59f745a009796c2fbbe86e58", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "week01_intro/seminar_gym_interface.py", "max_forks_repo_name": "mikita-zhuryk/Practical_RL", "max_forks_repo_head_hexsha": "4726da9d471f9a4f59f745a009796c2fbbe86e58", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.6369047619, "max_line_length": 171, "alphanum_fraction": 0.6997630842, "include": true, "reason": "import numpy", "num_tokens": 1162, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.334589441253186, "lm_q2_score": 0.16238003261321476, "lm_q1q2_score": 0.05433064438272965}}
{"text": "# coding=utf-8\nr\"\"\"\nCombinatorial classes of words.\n\nTo define a new class of words, please refer to the documentation file:\nsage/combinat/words/notes/word_inheritance_howto.txt\n\nAUTHORS:\n\n    - Franco Saliola (2008-12-17): merged into sage\n    - Sebastien Labbe (2008-12-17): merged into sage\n    - Arnaud Bergeron (2008-12-17): merged into sage\n    - Sebastien Labbe (2009-07-21): Improved morphism iterator (#6571).\n\nEXAMPLES::\n\n    sage: Words()\n    Words\n    sage: Words(4)\n    Words over {1, 2, 3, 4}\n    sage: Words('ab')\n    Words over {'a', 'b'}\n    sage: Words('natural numbers')\n    Words over Non negative integers\n\"\"\"\n#*****************************************************************************\n#       Copyright (C) 2008 Arnaud Bergeron <abergeron@gmail.com>,\n#                          Sébastien Labbé <slabqc@gmail.com>,\n#                          Franco Saliola <saliola@gmail.com>\n#\n#  Distributed under the terms of the GNU General Public License version 2 (GPLv2)\n#\n#  The full text of the GPLv2 is available at:\n#\n#                  http://www.gnu.org/licenses/\n#*****************************************************************************\nfrom sage.combinat.combinat import InfiniteAbstractCombinatorialClass\nfrom sage.combinat.combinat import CombinatorialObject\nfrom sage.combinat.words.alphabet import build_alphabet\nfrom sage.misc.lazy_attribute import lazy_attribute\nfrom sage.plot.misc import rename_keyword\nfrom sage.misc.mrange import xmrange\nfrom sage.rings.all import Infinity\nfrom sage.rings.integer import Integer\nfrom sage.rings.integer_ring import ZZ\nimport itertools\nfrom sage.structure.parent import Set_PythonType\n\ndef Words(alphabet=None, length=None, finite=True, infinite=True):\n    \"\"\"\n    Returns the combinatorial class of words of length k over an alphabet.\n\n    EXAMPLES::\n\n        sage: Words()\n        Words\n        sage: Words(length=7)\n        Words of length 7\n        sage: Words(5)\n        Words over {1, 2, 3, 4, 5}\n        sage: Words(5, 3)\n        Words of length 3 over {1, 2, 3, 4, 5}\n        sage: Words(5, infinite=False)\n        Finite Words over {1, 2, 3, 4, 5}\n        sage: Words(5, finite=False)\n        Infinite Words over {1, 2, 3, 4, 5}\n        sage: Words('ab')\n        Words over {'a', 'b'}\n        sage: Words('ab', 2)\n        Words of length 2 over {'a', 'b'}\n        sage: Words('ab', infinite=False)\n        Finite Words over {'a', 'b'}\n        sage: Words('ab', finite=False)\n        Infinite Words over {'a', 'b'}\n        sage: Words('positive integers', finite=False)\n        Infinite Words over Positive integers\n        sage: Words('natural numbers')\n        Words over Non negative integers\n    \"\"\"\n    if isinstance(alphabet, Words_all):\n        return alphabet\n    if alphabet is None:\n        if length is None:\n            if finite and infinite:\n                return Words_all()\n            elif finite:\n                raise NotImplementedError\n            else:\n                raise NotImplementedError\n        elif isinstance(length, (int,Integer)) and finite:\n            return Words_n(length)\n    else:\n        if isinstance(alphabet, (int,Integer)):\n            from sage.sets.integer_range import IntegerRange\n            alphabet = IntegerRange(1,alphabet+1)\n        elif alphabet == \"integers\" \\\n                or alphabet == \"positive integers\" \\\n                or alphabet == \"natural numbers\":\n            alphabet = build_alphabet(name=alphabet)\n        else:\n            alphabet = build_alphabet(data=alphabet)\n        if length is None:\n            if finite and infinite:\n                return Words_over_OrderedAlphabet(alphabet)\n            elif finite:\n                return FiniteWords_over_OrderedAlphabet(alphabet)\n            else:\n                return InfiniteWords_over_OrderedAlphabet(alphabet)\n        elif isinstance(length, (int,Integer)):\n                return FiniteWords_length_k_over_OrderedAlphabet(alphabet, length)\n    raise ValueError, \"do not know how to make a combinatorial class of words from your input\"\n\nfrom sage.structure.unique_representation import UniqueRepresentation\nclass Words_all(InfiniteAbstractCombinatorialClass):\n    r\"\"\"\n    TESTS::\n\n        sage: from sage.combinat.words.words import Words_all\n        sage: list(Words_all())\n        Traceback (most recent call last):\n        ...\n        NotImplementedError\n        sage: Words_all().list()\n        Traceback (most recent call last):\n        ...\n        NotImplementedError: infinite list\n        sage: Words_all().cardinality()\n        +Infinity\n\n    We would like the instance of this class to be unique::\n\n        sage: Words() is Words()   # todo: not implemented\n        True\n\n    .. WARNING::\n\n       The design of these classes is not particularly robust so extra care must\n       be taken when extending this class in order to prevent unintended\n       side-effects. This is particularly evident in the equality test\n       :meth:`__eq__` for words.\n    \"\"\"\n    @lazy_attribute\n    def _element_classes(self):\n        r\"\"\"\n        Returns a dictionary that gives the class of the element of self.\n\n        The word may be finite, infinite or of unknown length.\n        Its data may be str, list, tuple, a callable or an iterable.\n        For callable and iterable, the data may be cached.\n\n        TESTS::\n\n            sage: d = Words()._element_classes\n            sage: type(d)\n            <type 'dict'>\n            sage: len(d)\n            13\n            sage: e = Words('abcdefg')._element_classes\n            sage: d == e\n            True\n        \"\"\"\n        import sage.combinat.words.word as word\n        return {\n            'FiniteWord_list': word.FiniteWord_list,\n            'FiniteWord_str': word.FiniteWord_str,\n            'FiniteWord_tuple': word.FiniteWord_tuple,\n            'FiniteWord_callable_with_caching': word.FiniteWord_callable_with_caching,\n            'FiniteWord_callable': word.FiniteWord_callable,\n            'FiniteWord_iter_with_caching': word.FiniteWord_iter_with_caching,\n            'FiniteWord_iter': word.FiniteWord_iter,\n            'InfiniteWord_callable_with_caching': word.InfiniteWord_callable_with_caching,\n            'InfiniteWord_callable': word.InfiniteWord_callable,\n            'InfiniteWord_iter_with_caching': word.InfiniteWord_iter_with_caching,\n            'InfiniteWord_iter': word.InfiniteWord_iter,\n            'Word_iter_with_caching': word.Word_iter_with_caching,\n            'Word_iter': word.Word_iter\n            }\n\n    def __call__(self, data=None, length=None, datatype=None, caching=True, **kwds):\n        r\"\"\"\n        Construct a new word object with parent self.\n\n        INPUT:\n\n        -  ``data`` - (default: None) list, string, tuple, iterator, None\n           (shorthand for []), or a callable defined on [0,1,...,length].\n\n        -  ``length`` - (default: None) This is dependent on the type of data.\n           It is ignored for words defined by lists, strings, tuples,\n           etc., because they have a naturally defined length.\n           For callables, this defines the domain of definition,\n           which is assumed to be [0, 1, 2, ..., length-1].\n           For iterators: Infinity if you know the iterator will not\n           terminate (default); \"unknown\" if you do not know whether the\n           iterator terminates; \"finite\" if you know that the iterator\n           terminates, but do know know the length.\n\n        -  ``datatype`` - (default: None) None, \"list\", \"str\", \"tuple\", \"iter\",\n           \"callable\" or \"pickled_function\". If None, then the function tries\n           to guess this from the data.\n\n        -  ``caching`` - (default: True) True or False. Whether to keep a cache\n           of the letters computed by an iterator or callable.\n\n        NOTE:\n\n            We only check that the first 40 letters of the word are\n            actually in the alphabet. This is a quick check implemented to\n            test for small programming errors. Since we also support\n            infinite words, we cannot really implement a more accurate\n            check.\n\n        EXAMPLES::\n\n            sage: from itertools import count\n            sage: Words()(count())\n            word: 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,...\n            sage: Words(range(10))(count())\n            Traceback (most recent call last):\n            ...\n            ValueError: 10 not in alphabet!\n            sage: Words()(\"abba\")\n            word: abba\n            sage: Words(\"ab\")(\"abba\")\n            word: abba\n            sage: Words(\"ab\")(\"abca\")\n            Traceback (most recent call last):\n            ...\n            ValueError: c not in alphabet!\n        \"\"\"\n        from sage.combinat.words.word import Word\n        kwds['data'] = data\n        kwds['length'] = length\n        kwds['datatype'] = datatype\n        kwds['caching'] = caching\n        #kwds['alphabet'] = self\n\n        # The function _construct_word handles the construction of the words.\n        w = self._construct_word(**kwds)\n        self._check(w)\n        return w\n\n    def _construct_word(self, data=None, length=None, datatype=None, caching=True):\n        r\"\"\"\n        Construct a word.\n\n        INPUT:\n\n        -  ``data`` - (default: None) list, string, tuple, iterator, None\n           (shorthand for []), or a callable defined on [0,1,...,length].\n\n        -  ``length`` - (default: None) This is dependent on the type of data.\n           It is ignored for words defined by lists, strings, tuples,\n           etc., because they have a naturally defined length.\n           For callables, this defines the domain of definition,\n           which is assumed to be [0, 1, 2, ..., length-1].\n           For iterators: Infinity if you know the iterator will not\n           terminate (default); \"unknown\" if you do not know whether the\n           iterator terminates; \"finite\" if you know that the iterator\n           terminates, but do know know the length.\n\n        -  ``datatype`` - (default: None) None, \"list\", \"str\", \"tuple\", \"iter\",\n           \"callable\". If None, then the function\n           tries to guess this from the data.\n        -  ``caching`` - (default: True) True or False. Whether to keep a cache\n           of the letters computed by an iterator or callable.\n\n        .. note::\n\n           Be careful when defining words using callables and iterators. It\n           appears that islice does not pickle correctly causing various errors\n           when reloading. Also, most iterators do not support copying and\n           should not support pickling by extension.\n\n        EXAMPLES:\n\n        Empty word::\n\n            sage: Words()._construct_word()\n            word:\n\n        Word with string::\n\n            sage: Words()._construct_word(\"abbabaab\")\n            word: abbabaab\n\n        Word with string constructed from other types::\n\n            sage: Words()._construct_word([0,1,1,0,1,0,0,1], datatype=\"str\")\n            word: 01101001\n            sage: Words()._construct_word((0,1,1,0,1,0,0,1), datatype=\"str\")\n            word: 01101001\n\n        Word with list::\n\n            sage: Words()._construct_word([0,1,1,0,1,0,0,1])\n            word: 01101001\n\n        Word with list constructed from other types::\n\n            sage: Words()._construct_word(\"01101001\", datatype=\"list\")\n            word: 01101001\n            sage: Words()._construct_word((0,1,1,0,1,0,0,1), datatype=\"list\")\n            word: 01101001\n\n        Word with tuple::\n\n            sage: Words()._construct_word((0,1,1,0,1,0,0,1))\n            word: 01101001\n\n        Word with tuple constructed from other types::\n\n            sage: Words()._construct_word([0,1,1,0,1,0,0,1], datatype=\"tuple\")\n            word: 01101001\n            sage: Words()._construct_word(\"01101001\", datatype=\"str\")\n            word: 01101001\n\n        Word with iterator::\n\n            sage: from itertools import count\n            sage: Words()._construct_word(count())\n            word: 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,...\n            sage: Words()._construct_word(iter(\"abbabaab\")) # iterators default to infinite words\n            word: abbabaab\n            sage: Words()._construct_word(iter(\"abbabaab\"), length=\"unknown\")\n            word: abbabaab\n            sage: Words()._construct_word(iter(\"abbabaab\"), length=\"finite\")\n            word: abbabaab\n\n        Word with function (a 'callable')::\n\n            sage: f = lambda n : add(Integer(n).digits(2)) % 2\n            sage: Words()._construct_word(f)\n            word: 0110100110010110100101100110100110010110...\n            sage: Words()._construct_word(f, length=8)\n            word: 01101001\n\n        Word over a string with a parent::\n\n            sage: w = Words('abc')._construct_word(\"abbabaab\"); w\n            word: abbabaab\n            sage: w.parent()\n            Words over {'a', 'b', 'c'}\n\n        The default parent is the combinatorial class of all words::\n\n            sage: w = Words()._construct_word(\"abbabaab\"); w\n            word: abbabaab\n            sage: w.parent()\n            Words\n\n        Creation of a word from a word::\n\n            sage: Words([0,1,2,3])(Words([2,3])([2,2,2,3,3,2]))\n            word: 222332\n            sage: _.parent()\n            Words over {0, 1, 2, 3}\n\n        ::\n\n            sage: Words([3,2,1])(Words([2,3])([2,2,2,3,3,2]))\n            word: 222332\n            sage: _.parent()\n            Words over {3, 2, 1}\n\n        Construction of a word from a word when the parents are the same::\n\n            sage: W = Words()\n            sage: w = W(range(8))\n            sage: z = W(w)\n            sage: w is z\n            True\n\n        Construction of a word path from a finite word::\n\n            sage: W = Words('abcd')\n            sage: P = WordPaths('abcd')\n            sage: w = W('aaab')\n            sage: P(w)\n            Path: aaab\n\n        Construction of a word path from a Christoffel word::\n\n            sage: w = words.ChristoffelWord(5,8)\n            sage: w\n            word: 0010010100101\n            sage: P = WordPaths([0,1,2,3])\n            sage: P(w)\n            Path: 0010010100101\n\n        Construction of a word represented by a list from a word\n        represented by a str ::\n\n            sage: w = Word('ababbbabab')\n            sage: type(w)\n            <class 'sage.combinat.words.word.FiniteWord_str'>\n            sage: z = Word(w, datatype='list')\n            sage: type(z)\n            <class 'sage.combinat.words.word.FiniteWord_list'>\n            sage: y = Word(w, alphabet='abc', datatype='list')\n            sage: type(y)\n            <class 'sage.combinat.words.word.FiniteWord_list'>\n\n        Creation of a word from a concatenation of words::\n\n            sage: W = Words()\n            sage: w = W() * W('a')\n            sage: Z = Words('ab')\n            sage: Z(w)\n            word: a\n\n        Creation of a word path from a FiniteWord_iter::\n\n            sage: w = words.FibonacciWord()\n            sage: f = w[:100]\n            sage: P = WordPaths([0,1,2,3])\n            sage: p = P(f); p\n            Path: 0100101001001010010100100101001001010010...\n            sage: p.length()\n            100\n\n        Creation of a word path from a FiniteWord_callable::\n\n            sage: g = Word(lambda n:n%2, length = 100)\n            sage: P = WordPaths([0,1,2,3])\n            sage: p = P(g); p\n            Path: 0101010101010101010101010101010101010101...\n            sage: p.length()\n            100\n\n        Creation of a word from a pickled function::\n\n            sage: f = lambda n : n % 10\n            sage: from sage.misc.fpickle import pickle_function\n            sage: s = pickle_function(f)\n            sage: Word(s, datatype='pickled_function')\n            word: 0123456789012345678901234567890123456789...\n\n        \"\"\"\n        from sage.combinat.words.abstract_word import Word_class\n        from sage.combinat.words.word_infinite_datatypes import WordDatatype_callable, WordDatatype_iter\n        from sage.combinat.words.word_datatypes import WordDatatype\n        if isinstance(data, Word_class):\n            ####################\n            # If `data` is already a word and if its parent is self,\n            # then return `data` (no matter what the parameter length,\n            # datatype and length are).\n            ###########################\n            if data.parent() is self:\n                return data\n            ###########################\n            # Otherwise, if self is not the parent of `data`, then we\n            # try to recover the data, the length and the datatype of the\n            # input `data`\n            ###########################\n            if isinstance(data,  WordDatatype_callable):\n                from sage.combinat.words.finite_word import CallableFromListOfWords\n                if isinstance(data._func, CallableFromListOfWords):\n                    # The following line is important because, in this case,\n                    # data._func is also a tuple (indeed\n                    # CallableFromListOfWords inherits from tuple)\n                    datatype = \"callable\"\n                if length is None:\n                    length = data._len\n                data = data._func\n            elif isinstance(data,  WordDatatype_iter):\n                if length is None:\n                    length = data._len\n                data = iter(data)\n            elif isinstance(data, WordDatatype):\n                data = data._data\n            else:\n                raise TypeError, \"Any instance of Word_class must be an instance of WordDatatype.\"\n\n        if data is None:\n            data = []\n\n        # Guess the datatype if it is not given.\n        if datatype is None:\n            if isinstance(data, (list, CombinatorialObject)):\n                datatype = \"list\"\n            elif isinstance(data, (str)):\n                datatype = \"str\"\n            elif isinstance(data, tuple):\n                datatype = \"tuple\"\n            elif callable(data):\n                datatype = \"callable\"\n            elif hasattr(data,\"__iter__\"):\n                datatype = \"iter\"\n            else:\n                raise ValueError, \"Cannot guess a datatype from data (=%s); please specify one\"%data\n        else:\n            # type check the datatypes\n            if datatype == \"iter\" and not hasattr(data, \"__iter__\"):\n                raise ValueError, \"Your data is not iterable\"\n            elif datatype == \"callable\" and not callable(data):\n                raise ValueError, \"Your data is not callable\"\n            elif datatype not in (\"list\", \"tuple\", \"str\",\n                                \"callable\", \"iter\", \"pickled_function\"):\n                raise ValueError, \"Unknown datatype (=%s)\" % datatype\n\n        # If `data` is a pickled_function, restore the function\n        if datatype == 'pickled_function':\n            from sage.misc.fpickle import unpickle_function\n            data = unpickle_function(data)\n            datatype = 'callable'\n\n        # Construct the word class and keywords\n        if datatype in ('list','str','tuple'):\n            cls_str = 'FiniteWord_%s'%datatype\n            kwds = dict(parent=self,data=data)\n        elif datatype == 'callable':\n            if length in (None, Infinity, 'infinite'):\n                cls_str = 'InfiniteWord_callable'\n            else:\n                cls_str = 'FiniteWord_callable'\n            if caching:\n                cls_str += '_with_caching'\n            kwds = dict(parent=self,callable=data,length=length)\n        elif datatype == 'iter':\n            if length in (None, Infinity, 'infinite'):\n                cls_str = 'InfiniteWord_iter'\n            elif length == 'finite':\n                cls_str = 'FiniteWord_iter'\n            elif length == 'unknown':\n                cls_str = 'Word_iter'\n            elif length in ZZ and length >= 0:\n                cls_str = 'FiniteWord_iter'\n            else:\n                raise ValueError, \"not a correct value for length (%s)\" % length\n            if caching:\n                cls_str += '_with_caching'\n            kwds = dict(parent=self,iter=data,length=length)\n        else:\n            raise ValueError, \"Not known datatype\"\n\n        wordclass = self._element_classes\n        cls = wordclass[cls_str]\n        w = cls(**kwds)\n        return w\n\n    def _check(self, w, length=40):\n        r\"\"\"\n        Check that the first length elements are actually in the alphabet.\n\n        NOTE:\n\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import Words_over_Alphabet\n            sage: W = Words_over_Alphabet(['a','b','c'])\n            sage: W._check('abcabc') is None\n            True\n            sage: W._check('abcabcd')\n            Traceback (most recent call last):\n            ...\n            ValueError: d not in alphabet!\n            sage: W._check('abcabc'*10+'z') is None\n            True\n            sage: W._check('abcabc'*10+'z', length=80)\n            Traceback (most recent call last):\n            ...\n            ValueError: z not in alphabet!\n        \"\"\"\n        for a in itertools.islice(w, length):\n            if a not in self._alphabet:\n                raise ValueError, \"%s not in alphabet!\" % a\n\n    def _repr_(self):\n        \"\"\"\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import Words_all\n            sage: Words_all()._repr_()\n            'Words'\n        \"\"\"\n        return 'Words'\n\n    def __contains__(self, x):\n        \"\"\"\n        Returns True if x is contained in self.\n\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import Words_all\n            sage: 2 in Words_all()\n            False\n            sage: [1,2] in Words_all()\n            False\n            sage: Words('ab')('abba') in Words_all()\n            True\n        \"\"\"\n        from sage.combinat.words.abstract_word import Word_class\n        return isinstance(x, Word_class)\n\n    def __eq__(self, other):\n        r\"\"\"\n        Returns True if self is equal to other and False otherwise.\n\n        EXAMPLES::\n\n            sage: Words('ab') == Words()\n            False\n            sage: Words() == Words('ab')\n            False\n            sage: Words('ab') == Words('ab')\n            True\n            sage: Words('ab') == Words('ba')\n            False\n            sage: Words('ab') == Words('abc')\n            False\n            sage: Words('abc') == Words('ab')\n            False\n\n        ::\n\n            sage: WordPaths('abcd') == Words('abcd')\n            True\n            sage: Words('abcd') == WordPaths('abcd')\n            True\n            sage: Words('bacd') == WordPaths('abcd')\n            False\n            sage: WordPaths('bacd') == WordPaths('abcd')\n            False\n\n        TESTS:\n\n        :trac:`15480`::\n\n            sage: Words(3, 10) == Words(3,900)\n            False\n            sage: Words(2, finite=False) == Words(2)\n            False\n            sage: Words(2) == Words(2,30)\n            False\n            sage: Words(10,0) == Words(20,0)\n            True\n            sage: WordPaths('abcd') == Words(\"abcd\",3)\n            False\n            sage: Words(3) == Words(3,finite=False)\n            False\n            sage: Words(3) == Words(3,infinite=False)\n            False\n        \"\"\"\n\n        from paths import WordPaths_all\n        # Specific case of Words_over_Alphabet and WordPath. See #15480\n        # i.e. when self,other in Words_over_Alphabet, WordPath and one of them at least is a wordpath\n        if ((isinstance(self,WordPaths_all) and isinstance(other,WordPaths_all)) or\n            (type(self) is Words_over_OrderedAlphabet and isinstance(other,WordPaths_all)) or\n            (type(other) is Words_over_OrderedAlphabet and isinstance(self,WordPaths_all))):\n            return self.alphabet() == other.alphabet()\n\n        if not (type(self) is type(other)):\n            return False\n\n        cardinality = self.cardinality()\n\n        if cardinality != other.cardinality():\n            return False\n        if cardinality == 1:\n            return True\n        if self.alphabet() != other.alphabet():\n            return False\n\n        # This method's code cannot be trusted. It's the only way I see to fix\n        # the wrong results reported in #15480. But really, this kind of\n        # code should not be trusted. It is likely to return wrong results if\n        # whenever new classes extending Words_all are added.\n        return True\n\n    def __ne__(self, other):\n        r\"\"\"\n        Returns True if self is not equal to other and False otherwise.\n\n        TESTS::\n\n            sage: Words('ab') != Words('ab')\n            False\n            sage: Words('ab') != Words('abc')\n            True\n            sage: Words('abc') != Words('ab')\n            True\n\n        ::\n\n            sage: WordPaths('abcd') != Words('abcd')\n            False\n            sage: Words('abcd') != WordPaths('abcd')\n            False\n\n        ::\n\n            Words('ab') != 2\n            True\n        \"\"\"\n        if isinstance(other, Words_all):\n            return not self.__eq__(other)\n        else:\n            return NotImplemented\n\n    _alphabet = Set_PythonType(object)\n\n    def alphabet(self):\n        r\"\"\"\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import Words_over_Alphabet\n            sage: W = Words_over_Alphabet([1,2,3])\n            sage: W.alphabet()\n            [1, 2, 3]\n            sage: from sage.combinat.words.alphabet import build_alphabet\n            sage: W = Words_over_Alphabet(build_alphabet('ab'))\n            sage: W.alphabet()\n            {'a', 'b'}\n        \"\"\"\n        return self._alphabet\n\n    def size_of_alphabet(self):\n        r\"\"\"\n        Returns the size of the alphabet.\n\n        EXAMPLES::\n\n            sage: Words().size_of_alphabet()\n            +Infinity\n        \"\"\"\n        return Infinity\n\n    cmp_letters = cmp\n\n    def has_letter(self, letter):\n        r\"\"\"\n        Returns True if the alphabet of self contains the given letter.\n\n        INPUT:\n\n        -  ``letter`` - a letter\n\n        EXAMPLES::\n\n            sage: W = Words()\n            sage: W.has_letter('a')\n            True\n            sage: W.has_letter(1)\n            True\n            sage: W.has_letter({})\n            True\n            sage: W.has_letter([])\n            True\n            sage: W.has_letter(range(5))\n            True\n            sage: W.has_letter(Permutation([]))\n            True\n\n            sage: from sage.combinat.words.words import Words_over_Alphabet\n            sage: W = Words_over_Alphabet(['a','b','c'])\n            sage: W.has_letter('a')\n            True\n            sage: W.has_letter('d')\n            False\n            sage: W.has_letter(8)\n            False\n        \"\"\"\n        return letter in self._alphabet\n\nclass Words_over_Alphabet(Words_all):\n    def __init__(self, alphabet):\n        \"\"\"\n        Words over Alphabet.\n\n        INPUT:\n\n        -  ``alphabet`` - assumed to be an instance of Alphabet, but no\n           type checking is done here.\n\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import Words_over_Alphabet\n            sage: W = Words_over_Alphabet([1,2,3])\n            sage: W == loads(dumps(W))\n            True\n\n        The input alphabet must be an instance of Alphabet::\n\n            sage: W = Words_over_Alphabet(Alphabet([1,2,3]))\n            sage: W([1,2,2,3])\n            word: 1223\n        \"\"\"\n        self._alphabet = alphabet\n\n    def _repr_(self):\n        \"\"\"\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import Words_over_Alphabet\n            sage: Words_over_Alphabet([1,2,3])._repr_()\n            'Words over [1, 2, 3]'\n        \"\"\"\n        return \"Words over %s\"%self._alphabet\n\n    def __contains__(self, x):\n        \"\"\"\n        Tests whether self contains x.\n\n        OUTPUT:\n            This method returns True if x is a word of the appropriate\n            length and the alphabets of the parents match. Returns False\n            otherwise.\n\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import Words_over_Alphabet\n            sage: from sage.combinat.words.alphabet import build_alphabet\n            sage: A = build_alphabet('ab')\n            sage: Words(A)('abba') in Words_over_Alphabet(A)\n            True\n            sage: Words(A)('aa') in Words_over_Alphabet(A)\n            True\n            sage: Words('a')('aa') in Words_over_Alphabet(A)\n            False\n            sage: 2 in Words_over_Alphabet([1,2,3])\n            False\n            sage: [2] in Words_over_Alphabet([1,2,3])\n            False\n            sage: [1, 'a'] in Words_over_Alphabet([1,2,3])\n            False\n        \"\"\"\n        from sage.combinat.words.abstract_word import Word_class\n        return isinstance(x, Word_class) and x.parent().alphabet() == self.alphabet()\n\n    def size_of_alphabet(self):\n        r\"\"\"\n        Returns the size of the alphabet.\n\n        EXAMPLES::\n\n            sage: Words('abcdef').size_of_alphabet()\n            6\n            sage: Words('').size_of_alphabet()\n            0\n        \"\"\"\n        return self.alphabet().cardinality()\n\n    def identity_morphism(self):\n        r\"\"\"\n        Returns the identity morphism from self to itself.\n\n        EXAMPLES::\n\n            sage: W = Words('ab')\n            sage: W.identity_morphism()\n            WordMorphism: a->a, b->b\n\n        ::\n\n            sage: W = Words(range(3))\n            sage: W.identity_morphism()\n            WordMorphism: 0->0, 1->1, 2->2\n\n        There is no support yet for infinite alphabet::\n\n            sage: W = Words(alphabet=Alphabet(name='NN'))\n            sage: W\n            Words over Non negative integers\n            sage: W.identity_morphism()\n            Traceback (most recent call last):\n            ...\n            NotImplementedError: size of alphabet must be finite\n        \"\"\"\n        if self.size_of_alphabet() not in ZZ:\n            raise NotImplementedError, 'size of alphabet must be finite'\n        from sage.combinat.words.morphism import WordMorphism\n        return WordMorphism(dict((a,a) for a in self.alphabet()))\n\nclass Words_n(Words_all):\n    def __init__(self, n):\n        \"\"\"\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import Words_n\n            sage: w = Words_n(3)\n            sage: w == loads(dumps(w))\n            True\n        \"\"\"\n        self._n = n\n\n    def __repr__(self):\n        \"\"\"\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import Words_n\n            sage: Words_n(3).__repr__()\n            'Words of length 3'\n        \"\"\"\n        return \"Words of length %s\"%self._n\n\n    def __contains__(self, x):\n        \"\"\"\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import Words_n\n            sage: 2 in Words_n(3)\n            False\n            sage: [1,'a',3] in Words_n(3)\n            False\n            sage: [1,2] in Words_n(3)\n            False\n            sage: \"abc\" in Words_n(3)\n            False\n            sage: Words(\"abc\")(\"ababc\") in Words_n(3)\n            False\n            sage: Words([0,1])([1,0,1]) in Words_n(3)\n            True\n        \"\"\"\n        from sage.combinat.words.finite_word import FiniteWord_class\n        return isinstance(x, FiniteWord_class) and x.length() == self._n\n\nclass Words_over_OrderedAlphabet(Words_over_Alphabet):\n    def __init__(self, alphabet):\n        r\"\"\"\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import Words_over_OrderedAlphabet\n            sage: from sage.combinat.words.alphabet import build_alphabet\n            sage: A = build_alphabet(\"abc\")\n            sage: W = Words_over_OrderedAlphabet(A)\n            sage: W == loads(dumps(W))\n            True\n        \"\"\"\n        super(Words_over_OrderedAlphabet, self).__init__(alphabet)\n\n    def iterate_by_length(self, l=1):\n        r\"\"\"\n        Returns an iterator over all the words of self of length l.\n\n        INPUT:\n\n        - ``l`` - integer (default: 1), the length of the desired words\n\n        EXAMPLES::\n\n            sage: W = Words('ab')\n            sage: list(W.iterate_by_length(1))\n            [word: a, word: b]\n            sage: list(W.iterate_by_length(2))\n            [word: aa, word: ab, word: ba, word: bb]\n            sage: list(W.iterate_by_length(3))\n            [word: aaa,\n             word: aab,\n             word: aba,\n             word: abb,\n             word: baa,\n             word: bab,\n             word: bba,\n             word: bbb]\n            sage: list(W.iterate_by_length('a'))\n            Traceback (most recent call last):\n            ...\n            TypeError: the parameter l (='a') must be an integer\n        \"\"\"\n        if not isinstance(l, (int,Integer)):\n            raise TypeError, \"the parameter l (=%r) must be an integer\"%l\n        #if l == Integer(0):\n        #    yield self()\n        for w in xmrange([self.size_of_alphabet()]*l):\n            yield self(map(lambda x: self.alphabet().unrank(x), w))\n\n    def __iter__(self):\n        r\"\"\"\n        Returns an iterator over all the words of self.\n\n        The iterator outputs the words in lexicographic order,\n        based on the order of the letters in the alphabet.\n\n        EXAMPLES::\n\n            sage: W = Words([4,5])\n            sage: for w in W:\n            ...     if len(w)>3:\n            ...         break\n            ...     else:\n            ...         w\n            ...\n            word:\n            word: 4\n            word: 5\n            word: 44\n            word: 45\n            word: 54\n            word: 55\n            word: 444\n            word: 445\n            word: 454\n            word: 455\n            word: 544\n            word: 545\n            word: 554\n            word: 555\n            sage: W = Words([5,4])\n            sage: for w in W:\n            ...     if len(w)>3:\n            ...         break\n            ...     else:\n            ...         w\n            ...\n            word:\n            word: 5\n            word: 4\n            word: 55\n            word: 54\n            word: 45\n            word: 44\n            word: 555\n            word: 554\n            word: 545\n            word: 544\n            word: 455\n            word: 454\n            word: 445\n            word: 444\n        \"\"\"\n        for l in itertools.count():\n            for w in self.iterate_by_length(l):\n                yield w\n\n    @rename_keyword(deprecation=10134, l='arg')\n    def iter_morphisms(self, arg=None, codomain=None, min_length=1):\n        r\"\"\"\n        Iterate over all morphisms with domain ``self`` and the given\n        codomain.\n\n        INPUT:\n\n        - ``arg`` - (optional, default: None) It can be one of the following :\n\n          - ``None`` - then the method iterates through all morphisms.\n\n          - tuple `(a, b)` of two integers  - It specifies the range\n            ``range(a, b)`` of values to consider for the sum of the length\n            of the image of each letter in the alphabet.\n\n          - list of nonnegative integers - The length of the list must be\n            equal to the size of the alphabet, and the i-th integer of\n            ``arg`` determines the length of the word mapped to by the i-th\n            letter of the (ordered) alphabet.\n\n        - ``codomain`` - (default: None) a combinatorial class of words.\n          By default, ``codomain`` is ``self``.\n\n        - ``min_length`` - (default: 1) nonnegative integer. If ``arg`` is\n          not specified, then iterate through all the morphisms where the\n          length of the images of each letter in the alphabet is at least\n          ``min_length``. This is ignored if ``arg`` is a list.\n\n        OUTPUT:\n\n        iterator\n\n        EXAMPLES:\n\n        Iterator over all non-erasing morphisms::\n\n            sage: W = Words('ab')\n            sage: it = W.iter_morphisms()\n            sage: for _ in range(7): it.next()\n            WordMorphism: a->a, b->a\n            WordMorphism: a->a, b->b\n            WordMorphism: a->b, b->a\n            WordMorphism: a->b, b->b\n            WordMorphism: a->aa, b->a\n            WordMorphism: a->aa, b->b\n            WordMorphism: a->ab, b->a\n\n        Iterator over all morphisms including erasing morphisms::\n\n            sage: W = Words('ab')\n            sage: it = W.iter_morphisms(min_length=0)\n            sage: for _ in range(7): it.next()\n            WordMorphism: a->, b->\n            WordMorphism: a->a, b->\n            WordMorphism: a->b, b->\n            WordMorphism: a->, b->a\n            WordMorphism: a->, b->b\n            WordMorphism: a->aa, b->\n            WordMorphism: a->ab, b->\n\n        Iterator over morphisms where the sum of the lengths of the images\n        of the letters is in a specific range::\n\n            sage: for m in W.iter_morphisms((0, 3), min_length=0): m\n            WordMorphism: a->, b->\n            WordMorphism: a->a, b->\n            WordMorphism: a->b, b->\n            WordMorphism: a->, b->a\n            WordMorphism: a->, b->b\n            WordMorphism: a->aa, b->\n            WordMorphism: a->ab, b->\n            WordMorphism: a->ba, b->\n            WordMorphism: a->bb, b->\n            WordMorphism: a->a, b->a\n            WordMorphism: a->a, b->b\n            WordMorphism: a->b, b->a\n            WordMorphism: a->b, b->b\n            WordMorphism: a->, b->aa\n            WordMorphism: a->, b->ab\n            WordMorphism: a->, b->ba\n            WordMorphism: a->, b->bb\n\n        ::\n\n            sage: for m in W.iter_morphisms( (2, 4) ): m\n            WordMorphism: a->a, b->a\n            WordMorphism: a->a, b->b\n            WordMorphism: a->b, b->a\n            WordMorphism: a->b, b->b\n            WordMorphism: a->aa, b->a\n            WordMorphism: a->aa, b->b\n            WordMorphism: a->ab, b->a\n            WordMorphism: a->ab, b->b\n            WordMorphism: a->ba, b->a\n            WordMorphism: a->ba, b->b\n            WordMorphism: a->bb, b->a\n            WordMorphism: a->bb, b->b\n            WordMorphism: a->a, b->aa\n            WordMorphism: a->a, b->ab\n            WordMorphism: a->a, b->ba\n            WordMorphism: a->a, b->bb\n            WordMorphism: a->b, b->aa\n            WordMorphism: a->b, b->ab\n            WordMorphism: a->b, b->ba\n            WordMorphism: a->b, b->bb\n\n        Iterator over morphisms with specific image lengths::\n\n            sage: for m in W.iter_morphisms([0, 0]): m\n            WordMorphism: a->, b->\n            sage: for m in W.iter_morphisms([0, 1]): m\n            WordMorphism: a->, b->a\n            WordMorphism: a->, b->b\n            sage: for m in W.iter_morphisms([2, 1]): m\n            WordMorphism: a->aa, b->a\n            WordMorphism: a->aa, b->b\n            WordMorphism: a->ab, b->a\n            WordMorphism: a->ab, b->b\n            WordMorphism: a->ba, b->a\n            WordMorphism: a->ba, b->b\n            WordMorphism: a->bb, b->a\n            WordMorphism: a->bb, b->b\n            sage: for m in W.iter_morphisms([2, 2]): m\n            WordMorphism: a->aa, b->aa\n            WordMorphism: a->aa, b->ab\n            WordMorphism: a->aa, b->ba\n            WordMorphism: a->aa, b->bb\n            WordMorphism: a->ab, b->aa\n            WordMorphism: a->ab, b->ab\n            WordMorphism: a->ab, b->ba\n            WordMorphism: a->ab, b->bb\n            WordMorphism: a->ba, b->aa\n            WordMorphism: a->ba, b->ab\n            WordMorphism: a->ba, b->ba\n            WordMorphism: a->ba, b->bb\n            WordMorphism: a->bb, b->aa\n            WordMorphism: a->bb, b->ab\n            WordMorphism: a->bb, b->ba\n            WordMorphism: a->bb, b->bb\n\n        The codomain may be specified as well::\n\n            sage: Y = Words('xyz')\n            sage: for m in W.iter_morphisms([0, 2], codomain=Y): m\n            WordMorphism: a->, b->xx\n            WordMorphism: a->, b->xy\n            WordMorphism: a->, b->xz\n            WordMorphism: a->, b->yx\n            WordMorphism: a->, b->yy\n            WordMorphism: a->, b->yz\n            WordMorphism: a->, b->zx\n            WordMorphism: a->, b->zy\n            WordMorphism: a->, b->zz\n            sage: for m in Y.iter_morphisms([0,2,1], codomain=W): m\n            WordMorphism: x->, y->aa, z->a\n            WordMorphism: x->, y->aa, z->b\n            WordMorphism: x->, y->ab, z->a\n            WordMorphism: x->, y->ab, z->b\n            WordMorphism: x->, y->ba, z->a\n            WordMorphism: x->, y->ba, z->b\n            WordMorphism: x->, y->bb, z->a\n            WordMorphism: x->, y->bb, z->b\n            sage: it = W.iter_morphisms(codomain=Y)\n            sage: for _ in range(10): it.next()\n            WordMorphism: a->x, b->x\n            WordMorphism: a->x, b->y\n            WordMorphism: a->x, b->z\n            WordMorphism: a->y, b->x\n            WordMorphism: a->y, b->y\n            WordMorphism: a->y, b->z\n            WordMorphism: a->z, b->x\n            WordMorphism: a->z, b->y\n            WordMorphism: a->z, b->z\n            WordMorphism: a->xx, b->x\n\n        TESTS::\n\n            sage: list(W.iter_morphisms([1,0]))\n            [WordMorphism: a->a, b->, WordMorphism: a->b, b->]\n            sage: list(W.iter_morphisms([0,0], codomain=Y))\n            [WordMorphism: a->, b->]\n            sage: list(W.iter_morphisms([0, 1, 2]))\n            Traceback (most recent call last):\n            ...\n            TypeError: arg (=[0, 1, 2]) must be an iterable of 2 integers\n            sage: list(W.iter_morphisms([0, 'a']))\n            Traceback (most recent call last):\n            ...\n            TypeError: arg (=[0, 'a']) must be an iterable of 2 integers\n            sage: list(W.iter_morphisms([0, 1], codomain='a'))\n            Traceback (most recent call last):\n            ...\n            TypeError: codomain (=a) must be an instance of Words_over_OrderedAlphabet\n\n        The argument ``l`` is now deprecated::\n\n            sage: W = Words('ab')\n            sage: it = W.iter_morphisms(l=None)\n            doctest:...: DeprecationWarning: use the option 'arg' instead of 'l'\n            See http://trac.sagemath.org/10134 for details.\n        \"\"\"\n        n = self.size_of_alphabet()\n        # create an iterable of compositions (all \"compositions\" if arg is\n        # None, or [arg] otherwise)\n        if arg is None:\n            from sage.combinat.integer_list import IntegerListsLex\n            compositions = IntegerListsLex(itertools.count(),\n                    length=n, min_part = max(0,min_length))\n        elif isinstance(arg, tuple):\n            if not len(arg) == 2 or not all(isinstance(a, (int,Integer)) for a in arg):\n                raise TypeError(\"arg (=%s) must be a tuple of 2 integers\" %arg)\n            from sage.combinat.integer_list import IntegerListsLex\n            compositions = IntegerListsLex(range(*arg),\n                    length=n, min_part = max(0,min_length))\n        else:\n            arg = list(arg)\n            if (not len(arg) == n or not\n                    all(isinstance(a, (int,Integer)) for a in arg)):\n                raise TypeError(\n                    \"arg (=%s) must be an iterable of %s integers\" %(arg, n))\n            compositions = [arg]\n\n        # set the codomain\n        if codomain is None:\n            codomain = self\n        elif not isinstance(codomain, Words_over_OrderedAlphabet):\n            raise TypeError, \"codomain (=%s) must be an instance of Words_over_OrderedAlphabet\"%codomain\n\n        # iterate through the morphisms\n        from sage.combinat.words.morphism import WordMorphism\n        for composition in compositions:\n            cuts = [0] + list(composition)\n            for i in range(1,len(cuts)):\n                cuts[i] += cuts[i-1]\n            s = cuts[-1] # same but better than s = sum(composition)\n            for big_word in codomain.iterate_by_length(s):\n                d = {}\n                i = 0\n                for a in self.alphabet():\n                    d[a] = big_word[cuts[i]:cuts[i+1]]\n                    i += 1\n                yield WordMorphism(d, codomain=codomain)\n\n    def cmp_letters(self, letter1, letter2):\n        r\"\"\"\n        Returns a negative number, zero or a positive number if\n        ``letter1`` < ``letter2``, ``letter1`` == ``letter2`` or\n        ``letter1`` > ``letter2`` respectively.\n\n        INPUT:\n\n        - ``letter1`` - a letter in the alphabet\n        - ``letter2`` - a letter in the alphabet\n\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import Words_over_OrderedAlphabet\n            sage: from sage.combinat.words.alphabet import build_alphabet\n            sage: A = build_alphabet('woa')\n            sage: W = Words_over_OrderedAlphabet(A)\n            sage: W.cmp_letters('w','a')\n            -2\n            sage: W.cmp_letters('w','o')\n            -1\n            sage: W.cmp_letters('w','w')\n            0\n        \"\"\"\n        return int(self._alphabet.rank(letter1) - self._alphabet.rank(letter2))\n\nclass InfiniteWords_over_OrderedAlphabet(Words_over_OrderedAlphabet):\n    def __init__(self, alphabet):\n        r\"\"\"\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import InfiniteWords_over_OrderedAlphabet\n            sage: from sage.combinat.words.alphabet import build_alphabet\n            sage: A = build_alphabet(\"abc\")\n            sage: W = InfiniteWords_over_OrderedAlphabet(A)\n            sage: W == loads(dumps(W))\n            True\n        \"\"\"\n        super(InfiniteWords_over_OrderedAlphabet, self).__init__(alphabet)\n\n    def _repr_(self):\n        r\"\"\"\n        Returns a string representation of self.\n\n        EXAMPLES::\n\n            sage: Words('ab', finite=False)._repr_()\n            \"Infinite Words over {'a', 'b'}\"\n        \"\"\"\n        return \"Infinite Words over %s\" % self.alphabet()\n\nclass FiniteWords_over_OrderedAlphabet(Words_over_OrderedAlphabet):\n    def __init__(self, alphabet):\n        r\"\"\"\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import FiniteWords_over_OrderedAlphabet\n            sage: from sage.combinat.words.alphabet import build_alphabet\n            sage: A = build_alphabet(\"abc\")\n            sage: W = FiniteWords_over_OrderedAlphabet(A)\n            sage: W == loads(dumps(W))\n            True\n        \"\"\"\n        super(FiniteWords_over_OrderedAlphabet, self).__init__(alphabet)\n\n    def _repr_(self):\n        r\"\"\"\n        Returns a string representation of self.\n\n        EXAMPLES::\n\n            sage: Words('ab', infinite=False)._repr_()\n            \"Finite Words over {'a', 'b'}\"\n        \"\"\"\n        return \"Finite Words over %s\" % self.alphabet()\n\nclass FiniteWords_length_k_over_OrderedAlphabet(FiniteWords_over_OrderedAlphabet):\n    def __init__(self, alphabet, length):\n        \"\"\"\n        TESTS::\n\n            sage: from sage.combinat.words.words import FiniteWords_length_k_over_OrderedAlphabet\n            sage: A = sage.combinat.words.alphabet.build_alphabet([0,1])\n            sage: W = FiniteWords_length_k_over_OrderedAlphabet(A, 3)\n            sage: W == loads(dumps(W))\n            True\n        \"\"\"\n        super(FiniteWords_length_k_over_OrderedAlphabet, \\\n                self).__init__(alphabet)\n        self._length = length\n\n    def __contains__(self, x):\n        \"\"\"\n        EXAMPLES::\n\n            sage: from sage.combinat.words.words import FiniteWords_length_k_over_OrderedAlphabet\n            sage: A = sage.combinat.words.alphabet.build_alphabet([0,1])\n            sage: W = FiniteWords_length_k_over_OrderedAlphabet(A, 3)\n            sage: [1,2,3] in W\n            False\n            sage: [1,2] in W\n            False\n            sage: Words([0,1])([1,0,1]) in W\n            True\n            sage: Words([1,0])([1,0,1]) in W\n            False\n            sage: W([1,0,1]) in W\n            True\n            sage: Word([2,0]) in W\n            False\n        \"\"\"\n        if super(FiniteWords_length_k_over_OrderedAlphabet, \\\n                self).__contains__(x) and x.length() == self._length:\n            return True\n        else:\n            return False\n\n    def _repr_(self):\n        \"\"\"\n        TESTS::\n\n            sage: from sage.combinat.words.words import FiniteWords_length_k_over_OrderedAlphabet\n            sage: A = sage.combinat.words.alphabet.build_alphabet([1,0])\n            sage: FiniteWords_length_k_over_OrderedAlphabet(A,3)._repr_()\n            'Words of length 3 over {1, 0}'\n        \"\"\"\n        from sage.combinat.words.word_options import word_options\n        if word_options['old_repr']:\n            return \"Words over %s of length %s\"%(self.alphabet(), self._length)\n        return \"Words of length %s over %s\"%(self._length, self.alphabet())\n\n    def cardinality(self):\n        r\"\"\"\n        Returns the number of words of length `n` from alphabet.\n\n        EXAMPLES::\n\n            sage: Words(['a','b','c'], 4).cardinality()\n            81\n            sage: Words(3, 4).cardinality()\n            81\n            sage: Words(0,0).cardinality()\n            1\n            sage: Words(5,0).cardinality()\n            1\n            sage: Words(['a','b','c'],0).cardinality()\n            1\n            sage: Words(0,1).cardinality()\n            0\n            sage: Words(5,1).cardinality()\n            5\n            sage: Words(['a','b','c'],1).cardinality()\n            3\n            sage: Words(7,13).cardinality()\n            96889010407\n            sage: Words(['a','b','c','d','e','f','g'],13).cardinality()\n            96889010407\n        \"\"\"\n        n = self.size_of_alphabet()\n        return n**self._length\n\n    def list(self):\n        r\"\"\"\n        Returns a list of all the words contained in self.\n\n        EXAMPLES::\n\n            sage: Words(0,0).list()\n            [word: ]\n            sage: Words(5,0).list()\n            [word: ]\n            sage: Words(['a','b','c'],0).list()\n            [word: ]\n            sage: Words(5,1).list()\n            [word: 1, word: 2, word: 3, word: 4, word: 5]\n            sage: Words(['a','b','c'],2).list()\n            [word: aa, word: ab, word: ac, word: ba, word: bb, word: bc, word: ca, word: cb, word: cc]\n        \"\"\"\n        return list(self)\n\n    def __iter__(self):\n        \"\"\"\n        Returns an iterator for all of the words of length k from\n        ``self.alphabet()``. The iterator outputs the words in lexicographic\n        order, with respect to the ordering of the alphabet.\n\n        TESTS::\n\n            sage: [w for w in Words(['a', 'b'], 2)]\n            [word: aa, word: ab, word: ba, word: bb]\n            sage: [w for w in Words(['b', 'a'], 2)]\n            [word: bb, word: ba, word: ab, word: aa]\n            sage: [w for w in Words(['a', 'b'], 0)]\n            [word: ]\n            sage: [w for w in Words([], 3)]\n            []\n        \"\"\"\n        return super(FiniteWords_length_k_over_OrderedAlphabet, \\\n                self).iterate_by_length(self._length)\n\n    def iterate_by_length(self, length):\n        r\"\"\"\n        All words in this class are of the same length, so use iterator\n        instead.\n\n        TESTS::\n\n            sage: W = Words(['a', 'b'], 2)\n            sage: list(W.iterate_by_length(2))\n            [word: aa, word: ab, word: ba, word: bb]\n            sage: list(W.iterate_by_length(1))\n            []\n        \"\"\"\n        if length == self._length:\n            return iter(self)\n        else:\n            return iter([])\n\n###########################################################################\n##### DEPRECATION WARNINGS ################################################\n##### Added July 2009 #####################################################\n###########################################################################\n\ndef is_Words(obj):\n    r\"\"\"\n    Returns True if obj is a word set and False otherwise.\n\n    EXAMPLES::\n\n        sage: from sage.combinat.words.words import is_Words\n        sage: is_Words(33)\n        doctest:1: DeprecationWarning: is_Words is deprecated, use isinstance(your_object, Words_all) instead!\n        See http://trac.sagemath.org/6519 for details.\n        False\n        sage: is_Words(Words('ab'))\n        True\n    \"\"\"\n    from sage.misc.superseded import deprecation\n    deprecation(6519, \"is_Words is deprecated, use isinstance(your_object, Words_all) instead!\")\n    return isinstance(obj, Words_all)\n\n", "meta": {"hexsha": "82aa7d87766f1171a45c242badf07ececc7ba26d", "size": 52022, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/combinat/words/words.py", "max_stars_repo_name": "bopopescu/sagesmc", "max_stars_repo_head_hexsha": "e8d1d31f6f598dba2d763baa2d2e804338f9e89e", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2015-01-04T07:15:06.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T15:15:18.000Z", "max_issues_repo_path": "src/sage/combinat/words/words.py", "max_issues_repo_name": "bopopescu/sagesmc", "max_issues_repo_head_hexsha": "e8d1d31f6f598dba2d763baa2d2e804338f9e89e", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/combinat/words/words.py", "max_forks_repo_name": "bopopescu/sagesmc", "max_forks_repo_head_hexsha": "e8d1d31f6f598dba2d763baa2d2e804338f9e89e", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2016-09-28T13:12:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-12T09:28:34.000Z", "avg_line_length": 34.4060846561, "max_line_length": 131, "alphanum_fraction": 0.5324093653, "include": true, "reason": "import sage,from sage", "num_tokens": 12789, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.480478678047907, "lm_q2_score": 0.11279541821247763, "lm_q1q2_score": 0.054195793432592065}}
{"text": "\"\"\"Miscellaneous stuff that doesn't really fit anywhere else.\"\"\"\n\nfrom sympy.core import sympify\n\ndef default_sort_key(item):\n    \"\"\"\n    A default sort key for lists of SymPy objects to pass to functions like sorted().\n\n    This uses the default ordering. If you want a nonstandard ordering, you will\n    have to create your own sort key using the sort_key() method of the object.\n\n    **Examples**\n\n    >>> from sympy import Basic, S, I, default_sort_key\n    >>> from sympy.abc import x\n\n    >>> sorted([S(1)/2, I, -I], key=default_sort_key)\n    [1/2, -I, I]\n    >>> a = [S(1)/2, I, -I]\n    >>> a.sort(key=default_sort_key)\n    >>> a\n    [1/2, -I, I]\n\n    >>> b = S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n    >>> b.sort(key=default_sort_key)\n\n    The built-in functions min() and max() also take a key function (in Python\n    2.5 or higher), that this can be used for.\n    \"\"\"\n\n    #XXX: The following should also be in the docstring, but orders do not\n    # actually work at the moment.\n\n    # To use a nonstandard order, you must create your own sort key.  The default\n    # order is lex.\n\n    # >>> from sympy import sympify\n    # >>> mykey = lambda item: sympify(item).sort_key(order='rev-lex')\n    # >>> sorted([x, x**2, 1], key=default_sort_key)\n    # [x**2, x, 1]\n    # >>> sorted([x, x**2, 1], key=mykey)\n    # [1, x, x**2]\n\n    return sympify(item).sort_key()\n\nimport sys\nsize = getattr(sys, \"maxint\", None)\nif size is None: #Python 3 doesn't have maxint\n    size = sys.maxsize\nif size > 2**32:\n    ARCH = \"64-bit\"\nelse:\n    ARCH = \"32-bit\"\n", "meta": {"hexsha": "876e6a145a49041d99f071e10cd200abddfc31e2", "size": 1569, "ext": "py", "lang": "Python", "max_stars_repo_path": "sympy/utilities/misc.py", "max_stars_repo_name": "minrk/sympy", "max_stars_repo_head_hexsha": "1cc6e3837b8ed20ba52ea97298f31aa08b43c508", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2015-11-13T16:40:57.000Z", "max_stars_repo_stars_event_max_datetime": "2017-09-15T15:37:19.000Z", "max_issues_repo_path": "sympy_old/utilities/misc.py", "max_issues_repo_name": "curzel-it/KiPyCalc", "max_issues_repo_head_hexsha": "909c783d5e6967ea58ca93f875106d8a8e3ca5db", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2016-06-13T01:29:51.000Z", "max_issues_repo_issues_event_max_datetime": "2016-06-14T00:38:27.000Z", "max_forks_repo_path": "sympy_old/utilities/misc.py", "max_forks_repo_name": "curzel-it/KiPyCalc", "max_forks_repo_head_hexsha": "909c783d5e6967ea58ca93f875106d8a8e3ca5db", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-21T09:07:27.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T09:07:27.000Z", "avg_line_length": 29.0555555556, "max_line_length": 85, "alphanum_fraction": 0.6073932441, "include": true, "reason": "from sympy", "num_tokens": 484, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41869690935568665, "lm_q2_score": 0.12940273327036908, "lm_q1q2_score": 0.05418052448248182}}
{"text": "# -*- coding: utf-8 -*-\nr\"\"\"\nImplements a displayhook for Sage.\n\nThis displayhook has two new facilities, by default the displayhook contains a\nnew facility for displaying lists of matrices in an easier to read format::\n\n    sage: [identity_matrix(i) for i in range(2,5)]\n    [\n                    [1 0 0 0]\n           [1 0 0]  [0 1 0 0]\n    [1 0]  [0 1 0]  [0 0 1 0]\n    [0 1], [0 0 1], [0 0 0 1]\n    ]\n\nThis facility uses :meth:`_repr_` (and a simple string) to try do a nice read\nformat (see :meth:`sage.structure.parent._repr_option` for details).\n\nWith this displayhook there exists an other way for displaying object and more\ngenerally, all sage expression as an ASCII art object::\n\n    sage: from sage.misc.interpreter import get_test_shell\n    sage: shell = get_test_shell()\n    sage: shell.run_cell('%display ascii_art')\n    sage: shell.run_cell('integral(x^2/pi^x, x)')\n     / 2    2                      \\  -x*log(pi)\n    -\\x *log (pi) + 2*x*log(pi) + 2/*e\n    --------------------------------------------\n                         3\n                      log (pi)\n    sage: shell.run_cell(\"i = var('i')\")\n    sage: shell.run_cell('sum(i*x^i, i, 0, 10)')\n        10      9      8      7      6      5      4      3      2\n    10*x   + 9*x  + 8*x  + 7*x  + 6*x  + 5*x  + 4*x  + 3*x  + 2*x  + x\n    sage: shell.run_cell('StandardTableaux(4).list()')\n    [\n    [                                                                  1  4    1  3\n    [                 1  3  4    1  2  4    1  2  3    1  3    1  2    2       2\n    [   1  2  3  4,   2      ,   3      ,   4      ,   2  4,   3  4,   3   ,   4\n    <BLANKLINE>\n                1 ]\n        1  2    2 ]\n        3       3 ]\n    ,   4   ,   4 ]\n    sage: shell.run_cell('%display simple')\n\nThis other facility uses a simple `AsciiArt` object\n(see :class:`sage.misc.ascii_art.AsciiArt` and\n:meth:`sage.structure.parent._ascii_art_`).\n\nAUTHORS:\n\n- Bill Cauchois (2009): initial version\n- Jean-Baptiste Priez <jbp@kerios.fr> (2013): ASCII art\n\"\"\"\n\nimport sys, __builtin__\n\n\n# This is used to wrap lines when printing \"tall\" lists.\nMAX_COLUMN = 70\n\ndef _check_tall_list_and_format(the_list):\n    \"\"\"\n    First check whether a list is \"tall\" -- whether the reprs of the\n    elements of the list will span multiple lines and cause the list\n    to be printed awkwardly.  If not, this function returns ``None`` and\n    does nothing; you should revert back to the normal method for\n    printing an object (its repr). If so, return the string in the\n    special format. Note that the special format isn't just for\n    matrices. Any object with a multiline repr will be formatted.\n\n    INPUT:\n\n    - ``the_list`` - The list (or a tuple).\n\n    TESTS::\n\n        sage: from sage.misc.displayhook import format_obj\n\n    We test _check_tall_list_and_format() indirectly by calling format_obj() on\n    a list of matrices::\n\n        sage: print sage.misc.displayhook.format_obj( \\\n                [matrix([[1, 2, 3, 4], [5, 6, 7, 8]]) for i in xrange(7)])\n        [\n        [1 2 3 4]  [1 2 3 4]  [1 2 3 4]  [1 2 3 4]  [1 2 3 4]  [1 2 3 4]\n        [5 6 7 8], [5 6 7 8], [5 6 7 8], [5 6 7 8], [5 6 7 8], [5 6 7 8],\n        <BLANKLINE>\n        [1 2 3 4]\n        [5 6 7 8]\n        ]\n\n    We return ``None`` if we don't have anything special to do::\n\n        sage: format_obj('one-line string')\n        sage: format_obj(matrix([[1,2,3]]))\n    \"\"\"\n    # For every object to be printed, split its repr on newlines and store the\n    # result in this list.\n    split_reprs = []\n    tall = False\n    for elem in the_list:\n        split_reprs.append(`elem`.split('\\n'))\n        if len(split_reprs[-1]) > 1:\n            # Meanwhile, check to make sure the list is actually \"tall\".\n            tall = True\n    if not tall:\n        return None\n    # Figure out which type of parenthesis to use, based on the type of the_list.\n    if isinstance(the_list, tuple):\n        parens = '()'\n    elif isinstance(the_list, list):\n        parens = '[]'\n    else:\n        raise TypeError, 'expected list or tuple'\n\n    # running_lines is a list of lines, which are stored as lists of strings\n    # to be joined later. For each split repr, we add its lines to the\n    # running_lines array. When current_column exceeds MAX_COLUMN, process\n    # and output running_lines using _print_tall_list_row.\n    running_lines = [[]]\n    current_column = 0\n    s = [parens[0]]\n    for split_repr in split_reprs:\n        width = max(len(x) for x in split_repr)\n        if current_column + width > MAX_COLUMN and not (width > MAX_COLUMN):\n            s.extend(_tall_list_row(running_lines))\n            running_lines = [[]]\n            current_column = 0\n        current_column += width + 2\n        # Add the lines from split_repr to the running_lines array. It may\n        # be necessary to add or remove lines from either one so that the\n        # number of lines matches up.\n        for i in xrange(len(running_lines), len(split_repr)):\n            running_lines.insert(0, [' ' * len(x) for x in running_lines[-1]])\n        line_diff = len(running_lines) - len(split_repr)\n        for i, x in enumerate(split_repr):\n            running_lines[i + line_diff].append(x.ljust(width))\n        for i in xrange(line_diff):\n            running_lines[i].append(' ' * width)\n    # Output any remaining entries.\n    if len(running_lines[0]) > 0:\n        s.extend(_tall_list_row(running_lines, True))\n    s.append(parens[1])\n    return \"\\n\".join(s)\n\n# This helper function for _print_tall_list processes and outputs the\n# contents of the running_lines array.\ndef _tall_list_row(running_lines, last_row=False):\n    s=[]\n    for i, line in enumerate(running_lines):\n        if i + 1 != len(running_lines):\n            sep, tail = '  ', ''\n        else:\n            # The commas go on the bottom line of this row.\n            sep, tail = ', ', '' if last_row else ','\n        s.append(sep.join(line) + tail)\n    # Separate rows with a newline to make them stand out.\n    if not last_row:\n        s.append(\"\")\n    return s\n\ndef format_obj(obj):\n    \"\"\"\n    This function is used internally by the displayhook.\n\n    We attempt to keep ascii art of list/tuple members intact as we\n    print them. See :meth:`sage.structure.parent._repr_option` for\n    details.\n\n    OUTPUT:\n\n    Return a string if we want to print it in a special way;\n    otherwise, return ``None``.\n\n    EXAMPLES::\n\n        sage: import sage.misc.displayhook\n\n    For most objects, nothing is done (``None`` is returned):\n\n        sage: sage.misc.displayhook.format_obj('Hello, world!')\n        sage: sage.misc.displayhook.format_obj((1, 2, 3, 4))\n\n    We demonstrate the special format for lists of matrices::\n\n        sage: sage.misc.displayhook.format_obj( \\\n                [matrix([[1], [2]]), matrix([[3], [4]])])\n        '[\\n[1]  [3]\\n[2], [4]\\n]'\n\n    TESTS:\n\n    In #14466 we override IPython's special printing of ``type`` objects\n    and revert it to Python's standard string representation::\n\n        sage: shell=sage.misc.interpreter.get_test_shell()\n        sage: shell.displayhook(type)\n        <type 'type'>\n\n    \"\"\"\n    if isinstance(obj, type):\n        return repr(obj)\n    ascii_art = False\n    if isinstance(obj, (tuple, list)) and len(obj) > 0:\n        for o in obj:\n            try:\n                ascii_art = ascii_art or o.parent()._repr_option('element_ascii_art')\n            except (AttributeError, TypeError):\n                pass\n    if ascii_art:\n        return _check_tall_list_and_format(obj)\n    else:\n        return None\n\nclass DisplayHook(object):\n    \"\"\"\n    Display hook for Sage.\n\n    This is not used directly in interactive Sage (where we use the\n    IPython system for display hooks).  This class provides a way to\n    use the Sage display formatting when not using interactive Sage.\n    \"\"\"\n    def __init__(self, oldhook = sys.__displayhook__):\n        \"\"\"\n        Set the old display hook (default to repr)\n\n        EXAMPLES::\n\n            sage: from sage.misc.displayhook import DisplayHook\n            sage: def f(o): print repr(o)[:5], \"...\"\n            sage: d = DisplayHook(f)\n            sage: d(range(10))\n            [0, 1 ...\n        \"\"\"\n        self.oldhook = oldhook\n\n    def __call__(self, obj):\n        \"\"\"\n        Format the object using Sage's formatting, or format it using the old\n        display hook if Sage does not want to handle the object.\n\n        EXAMPLES::\n\n            sage: from sage.misc.displayhook import DisplayHook\n            sage: d = DisplayHook()\n            sage: d((identity_matrix(3), identity_matrix(3)))\n            (\n            [1 0 0]  [1 0 0]\n            [0 1 0]  [0 1 0]\n            [0 0 1], [0 0 1]\n            )\n        \"\"\"\n        s = format_obj(obj)\n        if s is not None:\n            print s\n            __builtin__._ = obj\n        else:\n            self.oldhook(obj)\n\nfrom IPython.core.formatters import PlainTextFormatter\nfrom ascii_art import ascii_art\nclass SagePlainTextFormatter(PlainTextFormatter):\n    r\"\"\"\n    A replacement for the plain text formatter which can use two facilities:\n\n    - correctly print lists of matrices or other objects (see\n      :meth:`sage.structure.parent._repr_option`),\n    - print ASCII art objects (like expressions) (see\n      :meth:`sage.structure.parent._ascii_art_`).\n\n    EXAMPLES::\n\n        sage: from sage.misc.interpreter import get_test_shell\n        sage: shell = get_test_shell()\n        sage: shell.display_formatter.formatters['text/plain']\n        <...displayhook.SagePlainTextFormatter object at 0x...>\n        sage: shell.run_cell('a = identity_matrix(ZZ, 2); [a,a]')\n        [\n        [1 0]  [1 0]\n        [0 1], [0 1]\n        ]\n    \"\"\"\n    def __call__(self, obj):\n        r\"\"\"\n        Computes the format data of ``result``.  If the\n        :func:`sage.misc.displayhook.format_obj` writes a string, then\n        we override IPython's :class:`DisplayHook` formatting.\n\n        EXAMPLES::\n\n            sage: from sage.misc.interpreter import get_test_shell\n            sage: shell = get_test_shell()\n            sage: shell.display_formatter.formatters['text/plain']\n            <...displayhook.SagePlainTextFormatter object at 0x...>\n            sage: shell.displayhook.compute_format_data(2)\n            {u'text/plain': '2'}\n            sage: a = identity_matrix(ZZ, 2)\n            sage: shell.displayhook.compute_format_data([a,a])\n            {u'text/plain': '[\\n[1 0]  [1 0]\\n[0 1], [0 1]\\n]'}\n            sage: from sage.misc.displayhook import SPTextFormatter\n            sage: SPTextFormatter.set_display(\"ascii_art\")\n            sage: i = var('i')\n            sage: shell.displayhook.compute_format_data(sum(i*x^i, i, 0, 10))\n            {u'text/plain':     10      9      8      7      6      5      4      3      2\n                            10*x   + 9*x  + 8*x  + 7*x  + 6*x  + 5*x  + 4*x  + 3*x  + 2*x  + x}\n        \"\"\"\n        s = self._format_obj(obj)\n        if s is None:\n            s = super(SagePlainTextFormatter, self).__call__(obj)\n        return s\n\n    _format_obj = lambda _, obj: format_obj(obj)\n\n    def set_display(self, mode=\"ascii_art\"):\n        r\"\"\"\n        Method uses to config the formatting method\n        (:meth:`simple_format_obj` or :func:`sage.misc.ascii_art.ascii_art`).\n\n        TESTS::\n\n            sage: [identity_matrix(i) for i in range(3,7)]\n            [\n                                             [1 0 0 0 0 0]\n                                [1 0 0 0 0]  [0 1 0 0 0 0]\n                     [1 0 0 0]  [0 1 0 0 0]  [0 0 1 0 0 0]\n            [1 0 0]  [0 1 0 0]  [0 0 1 0 0]  [0 0 0 1 0 0]\n            [0 1 0]  [0 0 1 0]  [0 0 0 1 0]  [0 0 0 0 1 0]\n            [0 0 1], [0 0 0 1], [0 0 0 0 1], [0 0 0 0 0 1]\n            ]\n            sage: from sage.misc.displayhook import SPTextFormatter\n            sage: SPTextFormatter.set_display(\"ascii_art\")\n            sage: from sage.misc.interpreter import get_test_shell\n            sage: shell = get_test_shell()\n            sage: shell.run_cell(\"i = var('i')\")\n            sage: shell.run_cell('sum(i*x^i, i, 0, 10)')\n                10      9      8      7      6      5      4      3      2\n            10*x   + 9*x  + 8*x  + 7*x  + 6*x  + 5*x  + 4*x  + 3*x  + 2*x  + x\n        \"\"\"\n        self._format_obj = {\n            \"ascii_art\": ascii_art,\n            \"simple\": format_obj\n        }[mode]\n\nSPTextFormatter = None\n\n", "meta": {"hexsha": "826a95ca1eadd2391201753d4acbf628b9de65f5", "size": 12332, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/misc/displayhook.py", "max_stars_repo_name": "felix-salfelder/sage", "max_stars_repo_head_hexsha": "5d8b2ff4794c44c7fa7a9d86ec567ecfa337e566", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-08-20T00:30:35.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-17T10:54:00.000Z", "max_issues_repo_path": "src/sage/misc/displayhook.py", "max_issues_repo_name": "felix-salfelder/sage", "max_issues_repo_head_hexsha": "5d8b2ff4794c44c7fa7a9d86ec567ecfa337e566", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/misc/displayhook.py", "max_forks_repo_name": "felix-salfelder/sage", "max_forks_repo_head_hexsha": "5d8b2ff4794c44c7fa7a9d86ec567ecfa337e566", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.5389048991, "max_line_length": 95, "alphanum_fraction": 0.5626824522, "include": true, "reason": "import sage,from sage", "num_tokens": 3502, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.37022540649291935, "lm_q2_score": 0.14608724704829565, "lm_q1q2_score": 0.05408521042188679}}
{"text": "import pathlib\n\nimport numpy_financial as npf\nimport pandas as pd\n\nimport streamlit as st\n\n\ndef main():\n    instructions_path = str(pathlib.Path(__file__).parent.resolve() / \"instructions.md\")\n    readme_text = st.markdown(get_file_content_as_string(instructions_path))\n\n    # Once we have the dependencies, add a selector for the app mode on the sidebar.\n    st.sidebar.title(\"What to do\")\n    app_mode = st.sidebar.selectbox(\n        \"Choose a chapter\",\n        [\"Home\", \"Compounding machine\", \"Finance starter kit\", \"Investing\"],\n    )\n    if app_mode == \"Home\":\n        st.sidebar.success(\"To continue select a chapter from the toolbar.\")\n    elif app_mode == \"Compounding machine\":\n        readme_text.empty()\n        compounding_machine()\n    elif app_mode == \"Finance starter kit\":\n        readme_text.empty()\n        finance_starter_kit()\n    elif app_mode == \"Investing\":\n        readme_text.empty()\n        investing()\n\n\ndef compounding_machine():\n\n    st.write('''\n    # Compounding: the eighth wonder of the world\n\n    What is compounding? Compounding is exponential increase in value due to earning interest on both the principal and the accumulated interest.\n\n    Let's break it down quickly with an example. Let's say that you lent me $1000 for three years, and I promised to pay you 10% for each year for this favor.\n\n    * The $1000 you loaned me is called the **principal**\n    * The 10% I pay you each year is the **interest** rate on the loan\n\n    With this arrangement, there are two ways that I might pay you back: simple interest and compound interest. In simple interest, I would simply pay you $100 (10% of $1000) at the end of each year, and return the $1000 at the end of the third year. Compound interest is more interesting. If we were to use compound interest, I would pay you 10% of the principal in the first year, then 10% of the principal *plus* the first year's interest, then 10% of the principal *plus* the first and second year's interest (and then I would also return the $1000). If you were calculating, that would be $100 in the first year (10% of $1000), $110 in the second year (10% of $1000+$100), and then $121 in the third year (10% of $1000+$100+$110).\n\n    As a result, you would end up with $1300 with simple interest and $1331 with compound interest. It might not seem like a big difference, but if you were to change it to a 20 year loan with the same initial principal of $1000 and 10% interest, you would end up with $3000 with simple interest and $6727.50 with compound interest. As the time horizon gets longer and longer, compounding's exponential growth becomes extremely obvious.\n\n    \"Compounding is the eighth wonder of the world.\" This quote is often apocryphally attributed to Albert Einstein, but the misattribution should not detract from its simplicity and profoundness.\n\n    ''')\n\n\n    st.write(\n    \"\"\"\n    ## Try it out\n\n    Since compounding is an exponential process, it's difficult to get a handle on it unless you try some simulations. I've designed a simple tool here that will let you play with the parameters of a compounding experiment:\n    * Starting principal: The amount of money you start with.\n    * Years: The number of years you want to run the compounding experiment for.\n    * Annual contribution: The amount you want to add to the compounding machine each year.\n    * Interest rate: The amount of interest you get paid each year.\n\n    Try extending the number of years we compound for. What happens when we contribute a small amount of money each year? And what happens to the final value when we change the interest rate around?\n\n    \"\"\"\n    )\n\n    with st.form(key=\"columns_in_form\"):\n        col1, col2 = st.beta_columns(2)\n        with col1:\n            principal_input = st.number_input(\n                \"Starting principal\", min_value=0, value=1000, key=\"principal\"\n            )\n            add_sum_input = st.number_input(\n                \"Annual contribution\", min_value=0, value=0, key=\"add_sum\"\n            )\n        with col2:\n            years_input = st.number_input(\n                \"Years\", min_value=0, max_value=100, value=10, key=\"years\"\n            )\n            interest_rate_input = st.number_input(\n                \"Interest rate (%)\", min_value=0, value=8, key=\"interest_rate\"\n            )\n        submitted = st.form_submit_button(\"Run\")\n\n    future_value = npf.fv(\n        rate=interest_rate_input / 100, nper=years_input, pmt=-add_sum_input, pv=-principal_input, when=\"begin\"\n    )\n\n    st.write(\"You'll have this left: $\", \"{:,}\".format(round(future_value, 2)))\n\n    @st.cache\n    def graph_compounding(years, principal, add_sum, interest_rate):\n        # graphing\n        year_list = []\n        value = []\n\n        for year in range(1, int(years)+1):\n            principal = (principal+add_sum)*(1+interest_rate/100)\n            year_list.append(year)\n            value.append(principal)\n\n        df_compounding = pd.DataFrame(zip(year_list, value), columns=['years', 'value'])\n        df_compounding.index = df_compounding['years'].values\n        del df_compounding['years']\n        return df_compounding.round(2)\n\n    df_compounding = graph_compounding(years_input, principal_input, add_sum_input, interest_rate_input)\n\n    st.write(\"### Growth over time\")\n\n    st.bar_chart(df_compounding)\n\n    st.write(\n        '''\n        It's not obvious how much compounding affects growth until we have an actual tangible demonstration like this. I understood it from a philosophical level before, but I never truly intuited and viscerally understood the power of compounding until I ran these calculations myself.\n\n        ## Chess and compounding\n\n        You might have heard this story before, but there is a famous legend about the origin of chess. Supposedly, when the inventor of the game showed it to the emperor of India, the emperor was so impressed by the new game that he promised any reward to the inventor.\n\n        The inventor replied, \"I only wish for this. Give me one grain of rice for the first square of the chessboard, two grains for the next square, four for the next, eight for the next, and so on for all 64 squares, with each square having double the number of grains as the square before.\"\n\n        The emperor agreed, amazed that the man had asked for such a small reward — or so he thought. After a week, his treasurer came back and informed him that the reward would add up to an astronomical sum, far greater than all the rice that could conceivably be produced in many centuries!\n\n        While this example of compounding is negative (for the king, at least), the very nature of compounding is neither good nor bad — it is simply a mathematical truth that exists. Compounding can either make or break you, but our job is to make compounding work for you in all facets of life. Harnessing compounding requires you to save or work a little bit harder today to reap a much greater reward tomorrow. Compounding is implementing delayed gratification and requires you to take a long-term view of life.\n\n        **In sum: use your youth and long time horizon — save (but not so much that you can't enjoy the present!) and plant the seeds for your own compounding machine.** We want to look back and thank our previous selves for doing this and setting up such a practice.\n\n        As they say, the best time to plant a tree was twenty years ago; the next best time is today.\n\n\n        '''\n    )\n\ndef finance_starter_kit():\n    st.write('''\n    # Finance starter kit\n\n    Your financial strength is a function of four simple variables:\n\n    1. **Income**: the money that you make\n    2. **Expenses**: the money that you spend\n    3. **Savings**: the pool of money you have saved\n    4. **Investments**: money available for your compounding machine\n\n    However, the first step is to understand exactly what is happening in each of these domains. Figure out how much income and expenses you have each month, and do a tally of the amount of money in your savings and investment accounts. The oft-repeated quote — What is measured is managed — is paramount here.\n\n    Once you figure out what is going in or out of each of these buckets, I'd encourage you to think about how you might slowly begin to improve each facet. Here are some heuristics and good rules of thumb:\n\n    ## Income\n\n    - mostly comes from your job, and also from alternative sources (freelancing)\n    - often neglected, but think about ways you can improve your income (negotiation of your salary, etc.)\n    - ensure that your monthly net income (income minus expenses) is positive\n\n    ## Expenses\n\n    - figure out what you enjoy, and feel comfortable spending in that category (to within reason)\n        - cut your expenses on everything else\n    - focus your time on saving expenses on big ticket items (e.g. car payments, mortgages, subscription services, student loans)\n    - other expenses: credit card debt, student loan debt, taxes\n    - figure out what your average monthly expense is\n\n    ## Savings\n\n    - rule of thumb: your savings account should contain 3-6 months worth of expenses (computed)\n        - do not put any money into investing until you have at least 3 months of savings\n\n    ## Investments\n\n    This is one of the most neglected parts of personal finance, yet it's arguably the most important (because this is where we get our compounding machine)!\n\n    Go to the next section to learn more!\n\n    ''')\n\ndef investing():\n\n    st.write('''\n    # Investing\n\n    **Beep boop bop 🤖️ This page is currently under construction.**\n    ''')\n\ndef get_file_content_as_string(path):\n    with open(path, \"r\") as file:\n        data = file.read()\n    return data\n\n\nif __name__ == \"__main__\":\n    main()\n", "meta": {"hexsha": "dede16cf2d45fb8faeeba6338f69e696fd5970d8", "size": 9719, "ext": "py", "lang": "Python", "max_stars_repo_path": "streamlit_app.py", "max_stars_repo_name": "nicholasachow/long_term_thinking", "max_stars_repo_head_hexsha": "1cad66e7472d71c2acbae4c9986532c7e5a1b59a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "streamlit_app.py", "max_issues_repo_name": "nicholasachow/long_term_thinking", "max_issues_repo_head_hexsha": "1cad66e7472d71c2acbae4c9986532c7e5a1b59a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "streamlit_app.py", "max_forks_repo_name": "nicholasachow/long_term_thinking", "max_forks_repo_head_hexsha": "1cad66e7472d71c2acbae4c9986532c7e5a1b59a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 50.0979381443, "max_line_length": 735, "alphanum_fraction": 0.7066570635, "include": true, "reason": "import numpy", "num_tokens": 2196, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46879062662624377, "lm_q2_score": 0.11436852618181247, "lm_q1q2_score": 0.05361489305509183}}
{"text": "\"\"\"\nCremona's tables of elliptic curves\n\nSage includes John Cremona's tables of elliptic curves in an\neasy-to-use format. An instance of the class CremonaDatabase()\ngives access to the database.\n\nIf the optional full CremonaDatabase is not installed, a mini-version\nis included by default with Sage.  It contains Weierstrass equations,\nrank, and torsion for curves up to conductor 10000.\n\nThe large database includes all curves in John Cremona's tables. It\nalso includes data related to the BSD conjecture and modular degrees\nfor all of these curves, and generators for the Mordell-Weil\ngroups. To install it, run the following in the shell::\n\n    sage -i database_cremona_ellcurve\n\nThis causes the latest version of the database to be downloaded from\nthe internet.\n\nBoth the mini and full versions of John Cremona's tables are stored in\nSAGE_SHARE/cremona as SQLite databases. The mini version has the layout::\n\n    CREATE TABLE t_class(conductor INTEGER, class TEXT PRIMARY KEY, rank INTEGER);\n    CREATE TABLE t_curve(class TEXT, curve TEXT PRIMARY KEY, eqn TEXT UNIQUE, tors INTEGER);\n    CREATE INDEX i_t_class_conductor ON t_class(conductor);\n    CREATE INDEX i_t_curve_class ON t_curve(class);\n\nwhile the full version has the layout::\n\n    CREATE TABLE t_class(conductor INTEGER, class TEXT PRIMARY KEY, rank INTEGER, L REAL, deg INTEGER);\n    CREATE TABLE t_curve(class TEXT, curve TEXT PRIMARY KEY, eqn TEXT UNIQUE, gens TEXT, tors INTEGER, cp INTEGER, om REAL, reg REAL, sha);\n    CREATE INDEX i_t_class_conductor ON t_class(conductor);\n    CREATE INDEX i_t_curve_class ON t_curve(class);\n\"\"\"\n#*****************************************************************************\n#       Copyright (C) 2014 John Cremona <john.cremona@gmail.com>\n#       Copyright (C) 2011 R. Andrew Ohana <andrew.ohana@gmail.com>\n#       Copyright (C) 2005 William Stein <wstein@gmail.com>\n#\n#  Distributed under the terms of the GNU General Public License (GPL)\n#  as published by the Free Software Foundation; either version 2 of\n#  the License, or (at your option) any later version.\n#                  http://www.gnu.org/licenses/\n#*****************************************************************************\n\nfrom __future__ import print_function\n\nimport os\nfrom sage.misc.prandom import randint\n\nimport sage.schemes.elliptic_curves.constructor as elliptic\nfrom sql_db import SQLDatabase, verify_column\nfrom sage.misc.package import is_package_installed\nfrom sage.env import SAGE_SHARE\nfrom sage.misc.all import walltime\n\nimport re\nimport string\n\n_cremonaSkeleton = {\n    't_class': {\n        'conductor': {'sql':'INTEGER', 'index':True},\n        'class':     {'sql':'TEXT',    'primary_key':True},\n        'rank':      {'sql':'INTEGER'},\n        'L':         {'sql':'REAL'},\n        'deg':       {'sql':'INTEGER'}\n    },\n    't_curve': {\n        'class':    {'sql':'TEXT', 'index':True},\n        'curve':    {'sql':'TEXT', 'primary_key':True},\n        'eqn':      {'sql':'TEXT', 'unique':True},\n        'gens':     {'sql':'TEXT'},\n        'tors':     {'sql':'INTEGER'},\n        'cp':       {'sql':'INTEGER'},\n        'om':       {'sql':'REAL'},\n        'reg':      {'sql':'REAL'},\n        'sha':      {'sql':'NOTYPE'}\n    }\n}\n_miniCremonaSkeleton = {\n    't_class': {\n        'conductor': {'sql':'INTEGER', 'index':True},\n        'class':     {'sql':'TEXT',    'primary_key':True},\n        'rank':      {'sql':'INTEGER'}\n    },\n    't_curve': {\n        'class':    {'sql':'TEXT', 'index':True},\n        'curve':    {'sql':'TEXT', 'primary_key':True},\n        'eqn':      {'sql':'TEXT', 'unique':True},\n        'tors':     {'sql':'INTEGER'}\n    }\n}\n\nfor t in _cremonaSkeleton:\n    for c in _cremonaSkeleton[t]:\n        _cremonaSkeleton[t][c] = verify_column(_cremonaSkeleton[t][c])\n    for c in _miniCremonaSkeleton[t]:\n        _miniCremonaSkeleton[t][c] = verify_column(_miniCremonaSkeleton[t][c])\n\ndef build(name, data_tgz, largest_conductor=0, mini=False, decompress=True):\n    \"\"\"\n    Build the CremonaDatabase with given name from scratch\n    using the data_tgz tarball.\n\n    .. note::\n\n           For data up to level 350000, this function takes about\n           3m40s.  The resulting database occupies 426MB disk space.\n\n    To create the large Cremona database from Cremona's data_tgz\n    tarball, obtainable from\n    http://homepages.warwick.ac.uk/staff/J.E.Cremona/ftp/data/, run\n    the following command::\n\n        sage: d = sage.databases.cremona.build('cremona','ecdata.tgz')   # not tested\n    \"\"\"\n    db_path = os.path.join(SAGE_SHARE,'cremona',name.replace(' ','_')+'.db')\n    if os.path.exists(db_path):\n        raise RuntimeError('Please (re)move %s before building '%db_path \\\n                + 'database')\n    if not os.path.exists(data_tgz):\n        raise IOError(\"The data file is not at %s\"%data_tgz)\n    t = walltime()\n\n    if decompress:\n        cmd = \"tar zxvf %s\"%data_tgz\n        n = os.system(cmd)\n        if n:\n            raise RuntimeError(\"Error extracting tarball.\")\n    if mini:\n        c = MiniCremonaDatabase(name,False,True)\n    else:\n        c = LargeCremonaDatabase(name,False,True)\n    # The following line assumes that the tarball extracts to a\n    # directory called 'ecdata'\n    c._init_from_ftpdata('ecdata', largest_conductor)\n    print(\"Total time: \", walltime(t))\n\ndef is_optimal_id(id):\n    \"\"\"\n    Returns true if the Cremona id refers to an optimal curve, and\n    false otherwise. The curve is optimal if the id, which is of the\n    form [letter code][number] has number 1.\n\n    .. note::\n\n       990h3 is the optimal curve in that class, so doesn't obey\n       this rule.\n\n    INPUT:\n\n    -  ``id`` - str of form letter code followed by an\n       integer, e.g., a3, bb5, etc.\n\n    OUTPUT: bool\n\n    EXAMPLES::\n\n        sage: from sage.databases.cremona import is_optimal_id\n        sage: is_optimal_id('b1')\n        True\n        sage: is_optimal_id('bb1')\n        True\n        sage: is_optimal_id('c1')\n        True\n        sage: is_optimal_id('c2')\n        False\n    \"\"\"\n    return id[-1] == '1' and not id[-2].isdigit()\n\ndef cremona_letter_code(n):\n    \"\"\"\n    Returns the Cremona letter code corresponding to an integer. For\n    example, 0 - a 25 - z 26 - ba 51 - bz 52 - ca 53 - cb etc.\n\n    .. note::\n\n       This is just the base 26 representation of n, where a=0, b=1,\n       ..., z=25. This extends the old Cremona notation (counting from\n       0) for the first 26 classes, and is different for classes above\n       26.\n\n    INPUT:\n\n    -  ``n`` (int) -- a non-negative integer\n\n    OUTPUT: str\n\n    EXAMPLES::\n\n        sage: from sage.databases.cremona import cremona_letter_code\n        sage: cremona_letter_code(0)\n        'a'\n        sage: cremona_letter_code(26)\n        'ba'\n        sage: cremona_letter_code(27)\n        'bb'\n        sage: cremona_letter_code(521)\n        'ub'\n        sage: cremona_letter_code(53)\n        'cb'\n        sage: cremona_letter_code(2005)\n        'czd'\n\n    TESTS::\n\n        sage: cremona_letter_code(QQ)\n        Traceback (most recent call last):\n        ...\n        ValueError: Cremona letter codes are only defined for non-negative integers\n        sage: cremona_letter_code(x)\n        Traceback (most recent call last):\n        ...\n        ValueError: Cremona letter codes are only defined for non-negative integers\n        sage: cremona_letter_code(-1)\n        Traceback (most recent call last):\n        ...\n        ValueError: Cremona letter codes are only defined for non-negative integers\n        sage: cremona_letter_code(3.14159)\n        Traceback (most recent call last):\n        ...\n        ValueError: Cremona letter codes are only defined for non-negative integers\n    \"\"\"\n    try:\n        m = int(n)\n        if n == m:\n            n = m\n        else:\n            n = -1\n    except (ValueError, TypeError):\n        n = -1\n\n    if n<0:\n        raise ValueError(\"Cremona letter codes are only defined for non-negative integers\")\n\n    if n == 0:\n        return \"a\"\n    s = \"\"\n    while n != 0:\n        s = chr(n%26+97) + s\n        n //= 26\n    return s\n\ndef old_cremona_letter_code(n):\n    r\"\"\"\n    Returns the *old* Cremona letter code corresponding to an integer.\n    integer.\n\n    For example::\n\n        1  --> A\n        26 --> Z\n        27 --> AA\n        52 --> ZZ\n        53 --> AAA\n        etc.\n\n    INPUT:\n\n    -  ``n`` - int\n\n    OUTPUT: str\n\n    EXAMPLES::\n\n        sage: from sage.databases.cremona import old_cremona_letter_code\n        sage: old_cremona_letter_code(1)\n        'A'\n        sage: old_cremona_letter_code(26)\n        'Z'\n        sage: old_cremona_letter_code(27)\n        'AA'\n        sage: old_cremona_letter_code(521)\n        'AAAAAAAAAAAAAAAAAAAAA'\n        sage: old_cremona_letter_code(53)\n        'AAA'\n        sage: old_cremona_letter_code(2005)\n        'CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC'\n    \"\"\"\n    n -= 1\n    k = n%26 + 65\n    label = chr(k)*int(n//26 + 1)\n    return label\n\nold_cremona_label_regex = re.compile(r'(\\d+)([A-Z]*)(\\d*)$')\ncremona_label_regex = re.compile(r'(\\d+)([a-z]*)(\\d*)$')\nlmfdb_label_regex = re.compile(r'(\\d+)\\.([a-z]+)(\\d*)$')\n\ndef parse_cremona_label(label):\n    \"\"\"\n    Given a Cremona label that defines an elliptic\n    curve, e.g., 11a1 or 37b3, parse the label and return the\n    conductor, isogeny class label, and number.\n\n    For this function, the curve number may be omitted, in which case\n    it defaults to 1.  If the curve number and isogeny class are both\n    omitted (label is just a string representing a conductor), then\n    the isogeny class defaults to 'a' and the number to 1.  Valid\n    labels consist of one or more digits, followed by zero or more\n    letters (either all in upper case for an old Cremona label, or all\n    in lower case), followed by zero or more digits.\n\n    INPUT:\n\n    -  ``label`` - str\n\n    OUTPUT:\n\n    -  ``int`` - the conductor\n    -  ``str`` - the isogeny class label\n    -  ``int`` - the number\n\n    EXAMPLES::\n\n        sage: from sage.databases.cremona import parse_cremona_label\n        sage: parse_cremona_label('37a2')\n        (37, 'a', 2)\n        sage: parse_cremona_label('37b1')\n        (37, 'b', 1)\n        sage: parse_cremona_label('10bb2')\n        (10, 'bb', 2)\n        sage: parse_cremona_label('11a')\n        (11, 'a', 1)\n        sage: parse_cremona_label('11')\n        (11, 'a', 1)\n\n    Valid old Cremona labels are allowed::\n\n        sage: parse_cremona_label('17CCCC')\n        (17, 'dc', 1)\n        sage: parse_cremona_label('5AB2')\n        Traceback (most recent call last):\n        ...\n        ValueError: 5AB2 is not a valid Cremona label\n\n    TESTS::\n\n        sage: from sage.databases.cremona import parse_cremona_label\n        sage: parse_cremona_label('x11')\n        Traceback (most recent call last):\n        ...\n        ValueError: x11 is not a valid Cremona label\n    \"\"\"\n    m = cremona_label_regex.match(str(label))\n    if m is None:\n        m = old_cremona_label_regex.match(str(label))\n        if m is None:\n            raise ValueError(label + \" is not a valid Cremona label\")\n\n    conductor, iso, num = m.groups()\n    if len(iso) == 0:\n        iso = \"a\"\n    if len(num) == 0:\n        num = \"1\"\n\n    # convert old cremona labels to new ones\n    if iso.upper() == iso and iso[0]*len(iso) == iso:\n        iso = cremona_letter_code((len(iso)-1)*26+ord(iso[0])-ord('A'))\n\n    # verify cremona label is valid\n    if iso.lower() != iso:\n        raise ValueError('%s is not a valid Cremona label'%label)\n\n    return int(conductor), iso, int(num)\n\ndef parse_lmfdb_label(label):\n    \"\"\"\n    Given an LMFDB label that defines an elliptic curve, e.g., 11.a1\n    or 37.b3, parse the label and return the conductor, isogeny class\n    label, and number.\n\n    The LMFDB label (named after the L-functions and modular forms\n    database), is determined by the following two orders:\n\n    - Isogeny classes with the same conductor are ordered\n      lexicographically by the coefficients in the q-expansion of the\n      associated modular form.\n\n    - Curves within the same isogeny class are ordered\n      lexicographically by the a-invariants of the minimal model.\n\n    The format is <conductor>.<iso><curve>, where the isogeny class is\n    encoded using the same base-26 encoding into letters used in\n    Cremona's labels.  For example, 990.h3 is the same as Cremona's 990j1\n\n    For this function, the curve number may be omitted, in which case\n    it defaults to 1.  If the curve number and isogeny class are both\n    omitted (label is just a string representing a conductor), then\n    the isogeny class defaults to 'a' and the number to 1.\n\n    INPUT:\n\n    -  ``label`` - str\n\n    OUTPUT:\n\n    -  ``int`` - the conductor\n    -  ``str`` - the isogeny class label\n    -  ``int`` - the number\n\n    EXAMPLES::\n\n        sage: from sage.databases.cremona import parse_lmfdb_label\n        sage: parse_lmfdb_label('37.a2')\n        (37, 'a', 2)\n        sage: parse_lmfdb_label('37.b')\n        (37, 'b', 1)\n        sage: parse_lmfdb_label('10.bb2')\n        (10, 'bb', 2)\n    \"\"\"\n    m = lmfdb_label_regex.match(str(label).lower())\n    if m is None:\n        raise ValueError(label + \" is not a valid LMFDB label\")\n    conductor, iso, num = m.groups()\n    if len(iso) == 0:\n        iso = \"a\"\n    if len(num) == 0:\n        num = \"1\"\n    return int(conductor), iso, int(num)\n\ndef split_code(key):\n    \"\"\"\n    Splits class+curve id string into its two parts.\n\n    EXAMPLES::\n\n        sage: import sage.databases.cremona as cremona\n        sage: cremona.split_code('ba2')\n        ('ba', '2')\n    \"\"\"\n    cu = re.split(\"[a-z]*\",key)[1]\n    cl =  re.split(\"[0-9]*\",key)[0]\n    return (cl,cu)\n\ndef class_to_int(k):\n    \"\"\"\n    Converts class id string into an integer. Note that this is the\n    inverse of cremona_letter_code.\n\n    EXAMPLES::\n\n        sage: import sage.databases.cremona as cremona\n        sage: cremona.class_to_int('ba')\n        26\n        sage: cremona.class_to_int('cremona')\n        821863562\n        sage: cremona.cremona_letter_code(821863562)\n        'cremona'\n    \"\"\"\n    kk = [string.ascii_lowercase.index(ch) for ch in list(k)]\n    kk.reverse()\n    return sum([kk[i]*26**i for i in range(len(kk))])\n\ndef cmp_code(key1,key2):\n    \"\"\"\n    Comparison function for curve id strings.\n\n    .. note::\n\n       Not the same as standard lexicographic order!\n\n    EXAMPLES::\n\n        sage: import sage.databases.cremona as cremona\n        sage: cremona.cmp_code('ba1','z1')\n        1\n\n    By contrast::\n\n        sage: cmp('ba1','z1')\n        -1\n    \"\"\"\n    cl1,cu1 = split_code(key1)\n    cl2,cu2 = split_code(key2)\n    d = class_to_int(cl1)-class_to_int(cl2)\n    if d!=0:  return d\n    return cmp(cu1,cu2)\n\ndef cremona_to_lmfdb(cremona_label, CDB=None):\n    \"\"\"\n    Converts a Cremona label into an LMFDB label.\n\n    See :func:`parse_lmfdb_label` for an explanation of LMFDB labels.\n\n    INPUT:\n\n    - ``cremona_label`` -- a string, the Cremona label of a curve.\n      This can be the label of a curve (e.g. '990j1') or of an isogeny\n      class (e.g. '990j')\n    - ``CDB`` -- the Cremona database in which to look up the isogeny\n      classes of the same conductor.\n\n    OUTPUT:\n\n    - ``lmfdb_label`` -- a string, the corresponding LMFDB label.\n\n    EXAMPLES::\n\n        sage: from sage.databases.cremona import cremona_to_lmfdb, lmfdb_to_cremona\n        sage: cremona_to_lmfdb('990j1')\n        '990.h3'\n        sage: lmfdb_to_cremona('990.h3')\n        '990j1'\n\n    TESTS::\n\n        sage: for label in ['5077a1','66a3','102b','420c2']:\n        ...       assert(lmfdb_to_cremona(cremona_to_lmfdb(label)) == label)\n        sage: for label in ['438.c2','306.b','462.f3']:\n        ...       assert(cremona_to_lmfdb(lmfdb_to_cremona(label)) == label)\n    \"\"\"\n    from sage.libs.pari.all import pari\n    m = cremona_label_regex.match(cremona_label)\n    if m is None:\n        raise ValueError(\"Invalid Cremona label\")\n    N, cremona_iso, cremona_number = m.groups()\n    if CDB is None:\n        CDB = CremonaDatabase()\n    classes = CDB.isogeny_classes(N)\n    ft = int(53)\n    tff = int(255) # This should be enough to distinguish between curves (using heuristics from Sato-Tate for example)\n    isos = []\n    for i, iso in enumerate(classes):\n        alist = iso[0][0]\n        E = pari(alist).ellinit(precision=ft)\n        isos.append((E.ellan(tff, python_ints=True), cremona_letter_code(i)))\n    isos.sort()\n    sorted_letters = [iso[1] for iso in isos]\n    lmfdb_iso = cremona_letter_code(sorted_letters.index(cremona_iso))\n    if len(cremona_number) > 0:\n        iso_class = sorted([(curve[0],str(i+1)) for i,curve in enumerate(classes[class_to_int(cremona_iso)])])\n        sorted_numbers = [curve[1] for curve in iso_class]\n        lmfdb_number = str(sorted_numbers.index(cremona_number)+1)\n        return N + '.' + lmfdb_iso + lmfdb_number\n    else:\n        return N + '.' + lmfdb_iso\n\ndef lmfdb_to_cremona(lmfdb_label, CDB=None):\n    \"\"\"\n    Converts an LMFDB labe into a Cremona label.\n\n    See :func:`parse_lmfdb_label` for an explanation of LMFDB labels.\n\n    INPUT:\n\n    - ``lmfdb_label`` -- a string, the LMFDB label of a curve.\n      This can be the label of a curve (e.g. '990.j1') or of an isogeny\n      class (e.g. '990.j')\n    - ``CDB`` -- the Cremona database in which to look up the isogeny\n      classes of the same conductor.\n\n    OUTPUT:\n\n    - ``cremona_label`` -- a string, the corresponding Cremona label.\n\n    EXAMPLES::\n\n        sage: from sage.databases.cremona import cremona_to_lmfdb, lmfdb_to_cremona\n        sage: lmfdb_to_cremona('990.h3')\n        '990j1'\n        sage: cremona_to_lmfdb('990j1')\n        '990.h3'\n    \"\"\"\n    from sage.libs.pari.all import pari\n    m = lmfdb_label_regex.match(lmfdb_label)\n    if m is None:\n        raise ValueError(\"Invalid LMFDB label\")\n    N, lmfdb_iso, lmfdb_number = m.groups()\n    if CDB is None:\n        CDB = CremonaDatabase()\n    classes = CDB.isogeny_classes(N)\n    ft = int(53)\n    tff = int(255) # This should be enough to distinguish between curves (using heuristics from Sato-Tate for example)\n    isos = []\n    for i, iso in enumerate(classes):\n        alist = iso[0][0]\n        E = pari(alist).ellinit(precision=ft)\n        isos.append((E.ellan(tff, python_ints=True), cremona_letter_code(i)))\n    isos.sort()\n    cremona_iso = isos[class_to_int(lmfdb_iso)][1]\n    if len(lmfdb_number) > 0:\n        iso_class = sorted([(curve[0],i+1) for i,curve in enumerate(classes[class_to_int(cremona_iso)])])\n        cremona_number = str(iso_class[int(lmfdb_number)-1][1])\n        return N + cremona_iso + cremona_number\n    else:\n        return N + cremona_iso\n\nclass MiniCremonaDatabase(SQLDatabase):\n    \"\"\"\n    The Cremona database of elliptic curves.\n\n    EXAMPLES::\n\n        sage: c = CremonaDatabase()\n        sage: c.allcurves(11)\n        {'a1': [[0, -1, 1, -10, -20], 0, 5],\n         'a2': [[0, -1, 1, -7820, -263580], 0, 1],\n         'a3': [[0, -1, 1, 0, 0], 0, 5]}\n    \"\"\"\n    def __init__(self, name, read_only=True, build=False):\n        \"\"\"\n        Initialize the database.\n\n        TESTS::\n\n            sage: c = CremonaDatabase('cremona mini')\n            sage: c.name\n            'cremona mini'\n        \"\"\"\n        self.name = name\n        name = name.replace(' ','_')\n        db_path = os.path.join(SAGE_SHARE, 'cremona', name+'.db')\n        if build:\n            if name is None:\n                raise RuntimeError('The database must have a name.')\n            if read_only:\n                raise RuntimeError('The database must not be read_only.')\n            SQLDatabase.__init__(self, db_path, read_only=read_only, \\\n                    skeleton=_miniCremonaSkeleton)\n            return\n        if not os.path.isfile(db_path):\n            raise ValueError(\"Desired database (='%s') does not \"%self.name \\\n                    + \"exist\")\n        SQLDatabase.__init__(self, db_path, read_only=read_only)\n        if self.get_skeleton() != _miniCremonaSkeleton:\n            raise RuntimeError('Database at %s does '%(self.__dblocation__) \\\n              + 'not appear to be a valid SQL Cremona database.')\n\n    def __iter__(self):\n        \"\"\"\n        Returns an iterator through all EllipticCurve objects in the\n        Cremona database.\n\n        TESTS::\n\n            sage: it = CremonaDatabase().__iter__()\n            sage: next(it).label()\n            '11a1'\n            sage: next(it).label()\n            '11a2'\n            sage: next(it).label()\n            '11a3'\n            sage: next(it).label()\n            '14a1'\n            sage: skip = [next(it) for _ in range(100)]\n            sage: next(it).label()\n            '45a3'\n        \"\"\"\n        query = \"SELECT curve FROM t_curve,t_class USING(class) ORDER BY conductor\"\n        for c in self.__connection__.cursor().execute(query):\n            yield self.elliptic_curve(c[0])\n\n    def __getitem__(self, N):\n        \"\"\"\n        If N is an integer, return all data about level N in the database.\n        If N is a string it must be a Cremona label, in which case return\n        the corresponding elliptic curve, if it is in the database.\n\n        INPUT:\n\n        -  ``N`` - int or str\n\n        OUTPUT: dict (if N is an int) or EllipticCurve (if N is a str)\n\n        TESTS::\n\n            sage: c = CremonaDatabase()\n            sage: c[11]['allcurves']['a2']\n            [[0, -1, 1, -7820, -263580], 0, 1]\n            sage: c['11a2']\n            Elliptic Curve defined by y^2 + y = x^3 - x^2 - 7820*x - 263580 over Rational Field\n        \"\"\"\n        if isinstance(N, str):\n            return self.elliptic_curve(N)\n\n        try:\n            N = int(N)\n        except ValueError:\n            raise KeyError(\"N (=%s) must be a string or positive integer.\"%N)\n\n        if N <= 0:\n            raise KeyError(\"N (=%s) must be a string or positive integer.\"%N)\n\n        ret = {'allcurves': self.allcurves(N)}\n        if hasattr(self, 'allbsd'):\n            ret['allbsd'] = self.allbsd(N)\n        if hasattr(self, 'degphi'):\n            ret['degphi'] = self.degphi(N)\n        if hasattr(self, 'allgens'):\n            ret['allgens'] = self.allgens(N)\n        return ret\n\n    def __repr__(self):\n        \"\"\"\n        String representation of this database.\n\n        TESTS::\n\n            sage: c = CremonaDatabase('cremona mini')\n            sage: c.__repr__()\n            \"Cremona's database of elliptic curves with conductor at most 9999\"\n        \"\"\"\n        return \"Cremona's database of elliptic curves with conductor at most \"\\\n            + str(self.largest_conductor())\n\n    def allcurves(self, N):\n        \"\"\"\n        Returns the allcurves table of curves of conductor N.\n\n        INPUT:\n\n        -  ``N`` - int, the conductor\n\n        OUTPUT:\n\n        -  ``dict`` - id:[ainvs, rank, tor], ...\n\n        EXAMPLES::\n\n            sage: c = CremonaDatabase()\n            sage: c.allcurves(11)['a3']\n            [[0, -1, 1, 0, 0], 0, 5]\n            sage: c.allcurves(12)\n            {}\n            sage: c.allcurves(12001)['a1']   # optional - database_cremona_ellcurve\n            [[1, 0, 0, -101, 382], 1, 1]\n        \"\"\"\n        ret = {}\n        for c in self.__connection__.cursor().execute('SELECT curve,eqn,' \\\n            + 'rank,tors FROM t_curve,t_class USING(class) WHERE ' \\\n            + 'conductor=?',(int(N),)):\n            N,iso,num = parse_cremona_label(c[0])\n            ret[iso+str(num)] = [eval(c[1]),c[2],c[3]]\n        return ret\n\n    def curves(self, N):\n        \"\"\"\n        Returns the curves table of all *optimal* curves of conductor N.\n\n        INPUT:\n\n        -  ``N`` - int, the conductor\n\n        OUTPUT:\n\n        -  ``dict`` - id:[ainvs, rank, tor], ...\n\n        EXAMPLES:\n\n        Optimal curves of conductor 37::\n\n            sage: CremonaDatabase().curves(37)\n            {'a1': [[0, 0, 1, -1, 0], 1, 1], 'b1': [[0, 1, 1, -23, -50], 0, 3]}\n\n        Note the 'h3', which is the unique case in the tables where\n        the optimal curve doesn't have label ending in 1::\n\n            sage: list(sorted(CremonaDatabase().curves(990).keys()))\n            ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h3', 'i1', 'j1', 'k1', 'l1']\n\n        TESTS::\n\n            sage: c = CremonaDatabase()\n            sage: c.curves(12001)['a1']   # optional - database_cremona_ellcurve\n            [[1, 0, 0, -101, 382], 1, 1]\n        \"\"\"\n        ret = {}\n        for c in self.__connection__.cursor().execute('SELECT curve,eqn,' \\\n            + 'rank,tors FROM t_curve,t_class USING(class) WHERE ' \\\n            + 'curve=class||1 AND conductor=?',(int(N),)):\n            N,iso,num = parse_cremona_label(c[0])\n            ret[iso+str(num)] = [eval(c[1]),c[2],c[3]]\n        if N == 990:\n            del ret['h1']\n            ret['h3'] = [[1,-1,1,-1568,-4669],int(1),int(6)]\n        return ret\n\n    def coefficients_and_data(self, label):\n        \"\"\"\n        Return the Weierstrass coefficients and other data for the\n        curve with given label.\n\n        EXAMPLES::\n\n            sage: c, d = CremonaDatabase().coefficients_and_data('144b1')\n            sage: c\n            [0, 0, 0, 6, 7]\n            sage: d['conductor']\n            144\n            sage: d['cremona_label']\n            '144b1'\n            sage: d['rank']\n            0\n            sage: d['torsion_order']\n            2\n\n        Check that :trac:`17904` is fixed::\n\n            sage: 'gens' in CremonaDatabase().coefficients_and_data('100467a2')[1] # optional - database_cremona_ellcurve\n            True\n\n\n        \"\"\"\n        # There are two possible strings: the Cremona label and the LMFDB label.\n        # They are distinguished by the presence of a period.\n        if label.find('.') == -1:\n            cremona_label = label\n            lmfdb_label = None\n        else:\n            cremona_label = lmfdb_to_cremona(label)\n            lmfdb_label = label\n\n        N, iso, num = parse_cremona_label(cremona_label)\n        label = str(N)+iso+str(num)\n        if self.get_skeleton() == _miniCremonaSkeleton:\n            q = self.__connection__.cursor().execute(\"SELECT eqn,rank,tors \" \\\n                + 'FROM t_curve,t_class USING(class) WHERE curve=?', (label,))\n        else:\n            q = self.__connection__.cursor().execute(\"SELECT eqn,rank,tors,\" \\\n                + \"deg,gens,cp,om,L,reg,sha FROM t_curve,t_class \" \\\n                + \"USING(class) WHERE curve=?\",(label,))\n        try:\n            c = next(q)\n        except StopIteration:\n            if N < self.largest_conductor():\n                message = \"There is no elliptic curve with label \" + label \\\n                    + \" in the database\"\n            elif is_package_installed('database_cremona_ellcurve'):\n                message = \"There is no elliptic curve with label \" + label \\\n                    + \" in the currently available databases\"\n            else:\n                message = \"There is no elliptic curve with label \" \\\n                    + label + \" in the default database; try installing \" \\\n                    + \"the optional package database_cremona_ellcurve which \" \\\n                    + \"contains the complete Cremona database\"\n            raise ValueError(message)\n        ainvs = eval(c[0])\n        data = {'cremona_label': label,\n                'rank': c[1],\n                'torsion_order': c[2],\n                'conductor': N}\n        if lmfdb_label:\n            data['lmfdb_label'] = lmfdb_label\n        if len(c) > 3:\n            data['modular_degree'] = (c[3])\n            data['gens'] = eval(c[4])\n            data['db_extra'] = list(c[5:])\n        return ainvs, data\n\n    def data_from_coefficients(self, ainvs):\n        \"\"\"\n        Return elliptic curve data for the curve with given\n        Weierstrass coefficients.\n\n        EXAMPLES::\n\n            sage: d = CremonaDatabase().data_from_coefficients([1, -1, 1, 31, 128])\n            sage: d['conductor']\n            1953\n            sage: d['cremona_label']\n            '1953c1'\n            sage: d['rank']\n            1\n            sage: d['torsion_order']\n            2\n\n        Check that :trac:`17904` is fixed::\n\n            sage: ai = EllipticCurve('100467a2').ainvs() # optional - database_cremona_ellcurve\n            sage: 'gens' in CremonaDatabase().data_from_coefficients(ai) # optional - database_cremona_ellcurve\n            True\n        \"\"\"\n        ainvs = str(list(ainvs))\n        if self.get_skeleton() == _miniCremonaSkeleton:\n            q = self.__connection__.cursor().execute(\"SELECT curve,rank,tors \"\n                + 'FROM t_curve,t_class USING(class) WHERE eqn=?',\n                (ainvs.replace(' ', ''),))\n        else:\n            q = self.__connection__.cursor().execute(\"SELECT curve,rank,tors,\"\n                + \"deg,gens,cp,om,L,reg,sha FROM t_curve,t_class \"\n                + \"USING(class) WHERE eqn=?\",\n                (ainvs.replace(' ', ''),))\n        try:\n            c = next(q)\n        except StopIteration:\n            raise RuntimeError(\"There is no elliptic curve with coefficients \"\n                               + ainvs + \" in the database\")\n        label = str(c[0])\n        N, iso, num = parse_cremona_label(label)\n        data = {'cremona_label': label,\n                'rank': c[1],\n                'torsion_order': c[2],\n                'conductor': N}\n        if len(c) > 3:\n            data['modular_degree'] = (c[3])\n            data['gens'] = eval(c[4])\n            data['db_extra'] = list(c[5:])\n        return data\n\n    def elliptic_curve_from_ainvs(self, ainvs):\n        \"\"\"\n        Returns the elliptic curve in the database of with minimal\n        ainvs, if it exists, or raises a RuntimeError exception\n        otherwise.\n\n        INPUT:\n\n        -  ``ainvs`` - list (5-tuple of int's); the minimal\n           Weierstrass model for an elliptic curve\n\n        OUTPUT: EllipticCurve\n\n        EXAMPLES::\n\n            sage: c = CremonaDatabase()\n            sage: c.elliptic_curve_from_ainvs([0, -1, 1, -10, -20])\n            Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field\n            sage: c.elliptic_curve_from_ainvs([1, 0, 0, -101, 382])  # optional - database_cremona_ellcurve\n            Elliptic Curve defined by y^2 + x*y = x^3 - 101*x + 382 over Rational Field\n\n        Old (pre-2006) Cremona labels are also allowed::\n\n            sage: c.elliptic_curve('9450KKKK1')\n            Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 - 5*x + 7 over Rational Field\n\n        Make sure :trac:`12565` is fixed::\n\n            sage: c.elliptic_curve('10a1')\n            Traceback (most recent call last):\n            ...\n            ValueError: There is no elliptic curve with label 10a1 in the database\n        \"\"\"\n        data = self.data_from_coefficients(ainvs)\n        return elliptic.EllipticCurve(ainvs, **data)\n\n    def elliptic_curve(self, label):\n        \"\"\"\n        Return an elliptic curve with given label with some data about it\n        from the database pre-filled in.\n\n        INPUT:\n\n        -  ``label`` - str (Cremona or LMFDB label)\n\n        OUTPUT:\n\n        - an :class:`sage.schemes.elliptic_curves.ell_rational_field.EllipticCurve_rational_field`\n\n        .. note::\n\n            For more details on LMFDB labels see :func:`parse_lmfdb_label`.\n\n        EXAMPLES::\n\n            sage: c = CremonaDatabase()\n            sage: c.elliptic_curve('11a1')\n            Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field\n            sage: c.elliptic_curve('12001a1')    # optional - database_cremona_ellcurve\n            Elliptic Curve defined by y^2 + x*y = x^3 - 101*x + 382 over Rational Field\n            sage: c.elliptic_curve('48c1')\n            Traceback (most recent call last):\n            ...\n            ValueError: There is no elliptic curve with label 48c1 in the database\n\n        You can also use LMFDB labels::\n\n            sage: c.elliptic_curve('462.f3')\n            Elliptic Curve defined by y^2 + x*y = x^3 - 363*x + 1305 over Rational Field\n        \"\"\"\n        ainvs, data = self.coefficients_and_data(label)\n        return elliptic.EllipticCurve(ainvs, **data)\n\n    def iter(self, conductors):\n        \"\"\"\n        Return an iterator through all curves in the database with given\n        conductors.\n\n        INPUT:\n\n        -  ``conductors`` - list or generator of ints\n\n        OUTPUT: generator that iterates over EllipticCurve objects.\n\n        EXAMPLES::\n\n            sage: [e.cremona_label() for e in CremonaDatabase().iter([11..15])]\n            ['11a1', '11a2', '11a3', '14a1', '14a2', '14a3', '14a4', '14a5',\n             '14a6', '15a1', '15a2', '15a3', '15a4', '15a5', '15a6', '15a7', '15a8']\n        \"\"\"\n        for N in conductors:\n            for c in self.__connection__.cursor().execute('SELECT curve ' \\\n                + 'FROM t_curve,t_class USING(class) WHERE conductor=?', \\\n                (int(N),)):\n                yield self.elliptic_curve(c[0])\n\n    def isogeny_classes(self, conductor):\n        \"\"\"\n        Return the allcurves data (ainvariants, rank and torsion) for the\n        elliptic curves in the database of given conductor as a list of\n        lists, one for each isogeny class. The curve with number 1 is\n        always listed first.\n\n        EXAMPLES::\n\n            sage: c = CremonaDatabase()\n            sage: c.isogeny_classes(11)\n            [[[[0, -1, 1, -10, -20], 0, 5],\n             [[0, -1, 1, -7820, -263580], 0, 1],\n             [[0, -1, 1, 0, 0], 0, 5]]]\n            sage: c.isogeny_classes(12001)   # optional - database_cremona_ellcurve\n            [[[[1, 0, 0, -101, 382], 1, 1]],\n             [[[0, 0, 1, -247, 1494], 1, 1]],\n             [[[0, 0, 1, -4, -18], 1, 1]],\n             [[[0, 1, 1, -10, 18], 1, 1]]]\n        \"\"\"\n        conductor=int(conductor)\n        classes = []\n        A = self.allcurves(conductor)\n        K = A.keys()\n        K.sort(cmp_code)\n        for k in K:\n            v = A[k]\n            # test if not first curve in class\n            if not (k[-1] == '1' and k[-2].isalpha()):\n                classes[len(classes)-1].append(v)\n            else:\n                classes.append([v])\n        return classes\n\n    def isogeny_class(self, label):\n        \"\"\"\n        Returns the isogeny class of elliptic curves that are\n        isogenous to the curve with given Cremona label.\n\n        INPUT:\n\n        -  ``label`` - string\n\n        OUTPUT:\n\n        -  ``list`` - list of EllipticCurve objects.\n\n        EXAMPLES::\n\n            sage: c = CremonaDatabase()\n            sage: c.isogeny_class('11a1')\n            [Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field,\n             Elliptic Curve defined by y^2 + y = x^3 - x^2 - 7820*x - 263580 over Rational Field,\n             Elliptic Curve defined by y^2 + y = x^3 - x^2 over Rational Field]\n            sage: c.isogeny_class('12001a1')   # optional - database_cremona_ellcurve\n            [Elliptic Curve defined by y^2 + x*y = x^3 - 101*x + 382 over Rational Field]\n        \"\"\"\n        conductor,iso,num=parse_cremona_label(label)\n        q = self.__connection__.cursor().execute(\"SELECT curve FROM t_curve \" \\\n            + \"WHERE class=?\",(str(conductor)+iso,))\n        return [self.elliptic_curve(c[0]) for c in q]\n\n    def iter_optimal(self, conductors):\n        \"\"\"\n        Return an iterator through all optimal curves in the database with given conductors.\n\n        INPUT:\n\n        - ``conductors`` - list or generator of ints\n\n        OUTPUT:\n\n        generator that iterates over EllipticCurve objects.\n\n        EXAMPLES:\n\n        We list optimal curves with conductor up to 20::\n\n            sage: [e.cremona_label() for e in CremonaDatabase().iter_optimal([11..20])]\n            ['11a1', '14a1', '15a1', '17a1', '19a1', '20a1']\n\n        Note the unfortunate 990h3 special case::\n\n            sage: [e.cremona_label() for e in CremonaDatabase().iter_optimal([990])]\n            ['990a1', '990b1', '990c1', '990d1', '990e1', '990f1', '990g1', '990h3', '990i1', '990j1', '990k1', '990l1']\n        \"\"\"\n        for N in conductors:\n            if N == 990:\n                for c in self.__connection__.cursor().execute('SELECT class ' \\\n                    + 'FROM t_class WHERE conductor=990'):\n                    if c[0][-1] == u'h':\n                        yield self.elliptic_curve(c[0]+u'3')\n                    else:\n                        yield self.elliptic_curve(c[0]+u'1')\n                continue\n            for c in self.__connection__.cursor().execute('SELECT curve ' \\\n                + 'FROM t_curve,t_class USING(class) WHERE curve=class||1 ' \\\n                + 'AND conductor=?',(int(N),)):\n                yield self.elliptic_curve(c[0])\n\n    def list(self, conductors):\n        \"\"\"\n        Returns a list of all curves with given conductors.\n\n        INPUT:\n\n        - ``conductors`` - list or generator of ints\n\n        OUTPUT:\n\n        - list of EllipticCurve objects.\n\n        EXAMPLES::\n\n            sage: CremonaDatabase().list([37])\n            [Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field,\n             Elliptic Curve defined by y^2 + y = x^3 + x^2 - 23*x - 50 over Rational Field,\n             Elliptic Curve defined by y^2 + y = x^3 + x^2 - 1873*x - 31833 over Rational Field,\n             Elliptic Curve defined by y^2 + y = x^3 + x^2 - 3*x + 1 over Rational Field]\n        \"\"\"\n        return list(self.iter(conductors))\n\n    def list_optimal(self, conductors):\n        \"\"\"\n        Returns a list of all optimal curves with given conductors.\n\n        INPUT:\n\n        -  ``conductors`` - list or generator of ints\n            list of EllipticCurve objects.\n\n        OUTPUT:\n\n        list of EllipticCurve objects.\n\n        EXAMPLES::\n\n            sage: CremonaDatabase().list_optimal([37])\n            [Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field,\n             Elliptic Curve defined by y^2 + y = x^3 + x^2 - 23*x - 50 over Rational Field]\n        \"\"\"\n        return list(self.iter_optimal(conductors))\n\n    def largest_conductor(self):\n        \"\"\"\n        The largest conductor for which the database is complete.\n\n        OUTPUT:\n\n        -  ``int`` - largest conductor\n\n        EXAMPLES::\n\n            sage: c = CremonaDatabase('cremona mini')\n            sage: c.largest_conductor()\n            9999\n        \"\"\"\n        if hasattr(self, '__largest_conductor__'):\n            return self.__largest_conductor__\n        #print \"Computing largest conductor.\"\n        q = self.__connection__.cursor().execute('SELECT conductor FROM ' \\\n            + 't_class ORDER BY conductor DESC LIMIT 1')\n        self.__largest_conductor__ = next(q)[0]\n        return self.__largest_conductor__\n\n    def smallest_conductor(self):\n        \"\"\"\n        The smallest conductor for which the database is complete: always 1.\n\n        OUTPUT:\n\n        -  ``int`` - smallest conductor\n\n        .. note::\n\n           This always returns the integer 1, since that is the\n           smallest conductor for which the database is complete,\n           although there are no elliptic curves of conductor 1.  The\n           smallest conductor of a curve in the database is 11.\n\n        EXAMPLES::\n\n            sage: CremonaDatabase().smallest_conductor()\n            1\n        \"\"\"\n        return 1\n\n    def conductor_range(self):\n        \"\"\"\n        Return the range of conductors that are covered by the database.\n\n        OUTPUT: tuple of ints (N1,N2+1) where N1 is the smallest and\n        N2 the largest conductor for which the database is complete.\n\n        EXAMPLES::\n\n            sage: c = CremonaDatabase('cremona mini')\n            sage: c.conductor_range()\n            (1, 10000)\n        \"\"\"\n        return 1, self.largest_conductor()+1\n\n    def number_of_curves(self,  N=0, i=0):\n        \"\"\"\n        Returns the number of curves stored in the database with conductor\n        N. If N = 0, returns the total number of curves in the database.\n\n        If i is nonzero, returns the number of curves in the i-th isogeny\n        class. If i is a Cremona letter code, e.g., 'a' or 'bc', it is\n        converted to the corresponding number.\n\n        INPUT:\n\n        -  ``N`` - int\n        -  ``i`` - int or str\n\n        OUTPUT: int\n\n        EXAMPLES::\n\n            sage: c = CremonaDatabase()\n            sage: c.number_of_curves(11)\n            3\n            sage: c.number_of_curves(37)\n            4\n            sage: c.number_of_curves(990)\n            42\n            sage: num = c.number_of_curves()\n        \"\"\"\n        if N == 0:\n            if hasattr(self, '__number_of_curves__'):\n                return self.__number_of_curves__\n            q = self.__connection__.cursor().execute('SELECT COUNT(curve) ' \\\n                + 'FROM t_curve')\n            self.__number_of_curves__ = next(q)[0]\n            return self.__number_of_curves__\n        if i == 0:\n            q = self.__connection__.cursor().execute('SELECT COUNT(curve) ' \\\n                + 'FROM t_curve,t_class USING(class) WHERE conductor=?', \\\n                (int(N),))\n            return next(q)[0]\n        if not isinstance(i, str):\n            i = cremona_letter_code(i)\n        q = self.__connection__.cursor().execute('SELECT COUNT(curve) FROM ' \\\n            + 't_curve WHERE class=?',(str(N)+i,))\n        return next(q)[0]\n\n    def number_of_isogeny_classes(self, N=0):\n        \"\"\"\n        Returns the number of isogeny classes of curves in the database of\n        conductor N. If N is 0, return the total number of isogeny classes\n        of curves in the database.\n\n        INPUT:\n\n        -  ``N`` - int\n\n        OUTPUT: int\n\n        EXAMPLES::\n\n            sage: c = CremonaDatabase()\n            sage: c.number_of_isogeny_classes(11)\n            1\n            sage: c.number_of_isogeny_classes(37)\n            2\n            sage: num = c.number_of_isogeny_classes()\n        \"\"\"\n        if N == 0:\n            if hasattr(self, '__number_of_isogeny_classes__'):\n                return self.__number_of_isogeny_classes__\n            q = self.__connection__.cursor().execute('SELECT COUNT(class) ' \\\n                + 'FROM t_class')\n            self.__number_of_isogeny_classes__ = next(q)[0]\n            return self.__number_of_isogeny_classes__\n        q = self.__connection__.cursor().execute('SELECT COUNT(class) FROM ' \\\n            + 't_class WHERE conductor=?',(int(N),))\n        return next(q)[0]\n\n    def random(self):\n        \"\"\"\n        Returns a random curve from the database.\n\n        EXAMPLES::\n\n            sage: CremonaDatabase().random() # random -- depends on database installed\n            Elliptic Curve defined by y^2 + x*y  = x^3 - x^2 - 224*x + 3072 over Rational Field\n        \"\"\"\n        N = randint(11, self.largest_conductor())\n        q = self.__connection__.cursor().execute('SELECT conductor FROM ' \\\n            + 't_class WHERE conductor>=? ORDER BY conductor',(int(N),))\n        try:\n            N = next(q)[0]\n        except StopIteration:\n            N = 11\n        iso = randint(0, self.number_of_isogeny_classes(N)-1)\n        iso = cremona_letter_code(iso)\n        num = randint(1, self.number_of_curves(N,iso))\n        return self.elliptic_curve(str(N)+iso+str(num))\n\n    ###############################################################################\n    # Functions for loading data from Cremona's ftpdata directory.\n    ###############################################################################\n    def _init_from_ftpdata(self, ftpdata, largest_conductor=0):\n        \"\"\"\n        Create the SQL Cremona Database from the Cremona data directory,\n        which is available from Cremona's website. I.e., just wget\n        Cremona's database to a local directory.\n\n        To create the large database from Cremona's text files, see\n        sage.databases.cremona.build, do NOT run this method directly.\n\n        EXAMPLES::\n\n            sage: d = sage.databases.cremona.MiniCremonaDatabase(name='cremona', read_only=False, rebuild=True)   # not tested\n            sage: d._init_from_ftpdata('.')     # not tested\n        \"\"\"\n        if self.__read_only__:\n            raise RuntimeError(\"The database must not be read_only.\")\n\n        if not os.path.exists(ftpdata):\n            raise RuntimeError(\"The cremona ftpdata directory '\" + ftpdata \\\n                + \"' does not exist.\")\n\n        if largest_conductor:\n            print(\"largest conductor =\", largest_conductor)\n            self.__largest_conductor__ =  largest_conductor\n\n        # Since July 2014 the data files have been arranged in\n        # subdirectories (see trac #16903).\n        allcurves_dir = os.path.join(ftpdata,'allcurves')\n        allbsd_dir = os.path.join(ftpdata,'allbsd')\n        allgens_dir = os.path.join(ftpdata,'allgens')\n        degphi_dir = os.path.join(ftpdata,'degphi')\n        num_curves, num_iso_classes = self._init_allcurves(allcurves_dir, largest_conductor)\n        self.__number_of_curves__ = num_curves\n        self.__number_of_isogeny_classes__ = num_iso_classes\n        if hasattr(self, 'degphi'):\n            self._init_degphi(degphi_dir, largest_conductor)\n        if hasattr(self, 'allbsd'):\n            self._init_allbsd(allbsd_dir, largest_conductor)\n        if hasattr(self, 'allgens'):\n            self._init_allgens(allgens_dir, largest_conductor)\n        self.vacuum()\n\n    def _init_allcurves(self, ftpdata, largest_conductor=0):\n        \"\"\"\n        Initialize the allcurves table by reading the corresponding ftpdata\n        files and importing them into the database.\n\n        To create the large database from Cremona's text files, see\n        sage.databases.cremona.build, do NOT run this method directly.\n\n        INPUT:\n\n        - `ftpdata` (string) -- the name of the directory in which the data is\n\n        -  ``largest_conductor`` - int (default: 0), if 0,\n           then only include data up to that conductor.\n\n        OUTPUT:\n\n        -  ``int`` - number_of_curves\n        -  ``int`` - number_of_isogeny_classes\n\n       EXAMPLES::\n\n            sage: d = sage.databases.cremona.MiniCremonaDatabase(name='cremona', read_only=False, rebuild=True)   # not tested\n            sage: d._init_allcurves('.', 11)    # not tested\n            (3, 1)\n        \"\"\"\n        if self.__read_only__:\n            raise RuntimeError(\"The database must not be read_only.\")\n        files = sorted(os.listdir(ftpdata))\n        name = 'allcurves'\n        num_curves = 0\n        num_iso_classes = 0\n        con = self.get_connection()\n        for F in files:\n            if not F[:len(name)] == name:\n                continue\n            print(\"Inserting\", F)\n            class_data = []\n            curve_data = []\n            for L in open(ftpdata + \"/\" + F).readlines():\n                N, iso, num, ainvs, r, tor = L.split()\n                if largest_conductor and int(N) > largest_conductor: break\n                cls = N+iso\n                cur = cls+num\n                if num == \"1\":\n                    class_data.append((N,cls,r))\n                    num_iso_classes += 1\n                curve_data.append((cur,cls,ainvs,tor))\n                num_curves += 1\n            con.executemany('INSERT INTO t_class (conductor,class,rank) ' \\\n                + 'VALUES (?,?,?)', class_data)\n            con.executemany('INSERT INTO t_curve (curve,class,eqn,tors) ' \\\n                + 'VALUES (?,?,?,?)', curve_data)\n            print(\"Committing...\")\n            print(\"num_iso_classes =\", num_iso_classes)\n            self.commit()\n            if largest_conductor and int(N) > largest_conductor: break\n        return num_curves, num_iso_classes\n\nclass LargeCremonaDatabase(MiniCremonaDatabase):\n    \"\"\"\n    The Cremona database of elliptic curves.\n\n    EXAMPLES::\n\n        sage: c = CremonaDatabase('cremona')  # optional - database_cremona_ellcurve\n        sage: c.allcurves(11)                 # optional - database_cremona_ellcurve\n        {'a1': [[0, -1, 1, -10, -20], 0, 5],\n        'a2': [[0, -1, 1, -7820, -263580], 0, 1],\n        'a3': [[0, -1, 1, 0, 0], 0, 5]}\n    \"\"\"\n    def __init__(self, name, read_only=True, build=False):\n        \"\"\"\n        Initialize the database.\n\n        TESTS::\n\n            sage: c = CremonaDatabase('cremona')    # optional - database_cremona_ellcurve\n            sage: c.name                            # optional - database_cremona_ellcurve\n            'cremona'\n        \"\"\"\n        self.name = name\n        name = name.replace(' ','_')\n        db_path = os.path.join(SAGE_SHARE, 'cremona', name+'.db')\n        if build:\n            if name is None:\n                raise RuntimeError('The database must have a name.')\n            if read_only:\n                raise RuntimeError('The database must not be read_only.')\n            SQLDatabase.__init__(self, db_path, read_only=read_only, \\\n                    skeleton=_cremonaSkeleton)\n            return\n        if not os.path.isfile(db_path):\n            raise ValueError(\"Desired database (='%s') does not \"%self.name \\\n                    + \"exist\")\n        SQLDatabase.__init__(self, db_path, read_only=read_only)\n        if self.get_skeleton() != _cremonaSkeleton:\n            raise RuntimeError('Database at %s does '%(self.__dblocation__) \\\n              + 'not appear to be a valid SQL Cremona database.')\n\n    def allbsd(self, N):\n        r\"\"\"\n        Return the allbsd table for conductor N. The entries are::\n\n            [id, tamagawa_product, Omega_E, L, Reg_E, Sha_an(E)]\n\n        where id is the isogeny class (letter) followed by a number, e.g.,\n        b3, and L is `L^r(E,1)/r!`, where E has rank r.\n\n        INPUT:\n\n        -  ``N`` - int, the conductor\n\n        OUTPUT: dict containing the allbsd table for each isogeny class\n        in conductor N\n\n        EXAMPLES::\n\n            sage: c = CremonaDatabase()\n            sage: c.allbsd(12)            # optional - database_cremona_ellcurve\n            {}\n            sage: c.allbsd(19)['a3']      # optional - database_cremona_ellcurve\n            [1, 4.07927920046493, 0.453253244496104, 1.0, 1]\n            sage: c.allbsd(12001)['a1']   # optional - database_cremona_ellcurve\n            [2, 3.27608135248722, 1.54910143090506, 0.236425971187952, 1.0]\n        \"\"\"\n        ret = {}\n        for c in self.__connection__.cursor().execute('SELECT curve,cp,om,L,' \\\n            + 'reg,sha FROM t_curve,t_class USING(class) WHERE conductor=?', \\\n            (int(N),)):\n            N,iso,num = parse_cremona_label(c[0])\n            ret[iso+str(num)] = list(c[1:])\n        return ret\n\n    def allgens(self, N):\n        \"\"\"\n        Return the allgens table for conductor N.\n\n        INPUT:\n\n        -  ``N`` - int, the conductor\n\n        OUTPUT:\n\n        -  ``dict`` - id:[points, ...], ...\n\n        EXAMPLES::\n\n            sage: c = CremonaDatabase()\n            sage: c.allgens(12)            # optional - database_cremona_ellcurve\n            {}\n            sage: c.allgens(1001)['a1']    # optional - database_cremona_ellcurve\n            [[61, 181, 1]]\n            sage: c.allgens(12001)['a1']   # optional - database_cremona_ellcurve\n            [[7, 2, 1]]\n        \"\"\"\n        ret = {}\n        for c in self.__connection__.cursor().execute('SELECT curve,gens ' \\\n            + 'FROM t_curve,t_class USING(class) WHERE conductor=?',(int(N),)):\n            N,iso,num = parse_cremona_label(c[0])\n            ret[iso+str(num)] = eval(c[1])\n        return ret\n\n    def degphi(self, N):\n        \"\"\"\n        Return the degphi table for conductor N.\n\n        INPUT:\n\n        -  ``N`` - int, the conductor\n\n        OUTPUT:\n\n        -  ``dict`` - id:degphi, ...\n\n        EXAMPLES::\n\n            sage: c = CremonaDatabase()\n            sage: c.degphi(11)            # optional - database_cremona_ellcurve\n            {'a1': 1}\n            sage: c.degphi(12001)['c1']   # optional - database_cremona_ellcurve\n            1640\n        \"\"\"\n        ret = {}\n        for c in self.__connection__.cursor().execute('SELECT curve,deg FROM' \\\n            + ' t_curve,t_class USING(class) WHERE curve=class||1 AND ' \\\n            + 'conductor=?', (int(N),)):\n            N,iso,num = parse_cremona_label(c[0])\n            ret[iso+str(num)] = c[1]\n        return ret\n\n    def _init_degphi(self, ftpdata, largest_conductor=0):\n        \"\"\"\n        Initialize the degphi table by reading the corresponding ftpdata\n        files and importing them into the database.\n\n        To create the large database from Cremona's text files, see\n        sage.databases.cremona.build, do NOT run this method directly.\n\n        EXAMPLES::\n\n            sage: d = sage.databases.cremona.LargeCremonaDatabase(name='cremona', read_only=False, rebuild=True)   # not tested\n            sage: d._init_degphi('.')           # not tested\n        \"\"\"\n        if self.__read_only__:\n            raise RuntimeError(\"The database must not be read_only.\")\n        files = sorted(os.listdir(ftpdata))\n        name = \"degphi\"\n        con = self.get_connection()\n        for F in files:\n            if not F[:len(name)] == name:\n                continue\n            print(\"Inserting\", F)\n            class_data = []\n            for L in open(ftpdata + \"/\" + F).readlines():\n                N, iso, num, degree, primes, curve = L.split()\n                if largest_conductor and int(N) > largest_conductor: break\n                class_data.append((degree,N+iso))\n            con.executemany('UPDATE t_class SET deg=? WHERE class=?', \\\n                class_data)\n            print(\"Committing...\")\n            self.commit()\n            if largest_conductor and int(N) > largest_conductor: break\n\n    def _init_allbsd(self, ftpdata, largest_conductor=0):\n        \"\"\"\n        Initialize the allbsd table by reading the corresponding ftpdata\n        files and importing them into the database.\n\n        To create the large database from Cremona's text files, see\n        sage.databases.cremona.build, do NOT run this method directly.\n\n        EXAMPLES::\n\n            sage: d = sage.databases.cremona.LargeCremonaDatabase(name='cremona', read_only=False, rebuild=True)   # not tested\n            sage: d._init_allbsd('.')           # not tested\n        \"\"\"\n        if self.__read_only__:\n            raise RuntimeError(\"The database must not be read_only.\")\n        files = sorted(os.listdir(ftpdata))\n        name = \"allbsd\"\n        con = self.get_connection()\n        for F in files:\n            if not F[:len(name)] == name:\n                continue\n            print(\"Inserting\", F)\n            curve_data = []\n            class_data = []\n            for L in open(ftpdata + \"/\" + F).readlines():\n                N, iso, num, eqn, rank, tor, cp, om, L, reg, sha  = L.split()\n                if largest_conductor and int(N) > largest_conductor: break\n                cls = N+iso\n                if num == \"1\":\n                    class_data.append((L,cls))\n                curve_data.append((cp,om,reg,eval(sha),cls+num))\n            con.executemany(\"UPDATE t_class SET L=? WHERE class=?\", class_data)\n            con.executemany(\"UPDATE t_curve SET cp=?,om=?,reg=?,sha=? WHERE \" \\\n                    + \"curve=?\", curve_data)\n            print(\"Committing...\")\n            self.commit()\n            if largest_conductor and int(N) > largest_conductor: break\n\n    def _init_allgens(self, ftpdata, largest_conductor=0):\n        \"\"\"\n        Initialize the allgens table by reading the corresponding ftpdata\n        files and importing them into the database.\n\n        To create the large database from Cremona's text files, see\n        sage.databases.cremona.build, do NOT run this method directly.\n\n        EXAMPLES::\n\n            sage: d = sage.databases.cremona.LargeCremonaDatabase(name='cremona', read_only=False, rebuild=True)   # not tested\n            sage: d._init_allgens('.')          # not tested\n        \"\"\"\n        if self.__read_only__:\n            raise RuntimeError(\"The database must not be read_only.\")\n        files = sorted(os.listdir(ftpdata))\n        name = \"allgens\"\n        con = self.get_connection()\n        for F in files:\n            if not F[:len(name)] == name:\n                continue\n            print(\"Inserting\", F)\n            curve_data = []\n            for L in open(ftpdata + \"/\" + F).readlines():\n                v = L.split()\n                if largest_conductor and int(v[0]) > largest_conductor: break\n                gens = '['+','.join(v[6:6+int(v[4])]).replace(':',',')+']'\n                curve_data.append((gens,''.join(v[:3])))\n            con.executemany(\"UPDATE t_curve SET gens=? WHERE curve=?\", \\\n                curve_data)\n            print(\"Committing...\")\n            if largest_conductor and int(v[0]) > largest_conductor: break\n\n_db = None\ndef CremonaDatabase(name=None,mini=None,set_global=None):\n    \"\"\"\n    Initializes the Cremona database with name ``name``. If ``name`` is\n    ``None`` it instead initializes large Cremona database (named 'cremona'),\n    if available or default mini Cremona database (named 'cremona mini').\n\n    If the Cremona database in question is in the format of the mini database,\n    you must set ``mini=True``, otherwise it must be set to ``False``.\n\n    If you would like other components of Sage to use this database, mark\n    ``set_global=True``.\n\n    TESTS::\n\n        sage: c = CremonaDatabase()\n        sage: isinstance(c, sage.databases.cremona.MiniCremonaDatabase)\n        True\n        sage: isinstance(c, sage.databases.cremona.LargeCremonaDatabase)  # optional - database_cremona_ellcurve\n        True\n\n    Verify that :trac:`12341` has been resolved::\n\n        sage: c = CremonaDatabase('should not exist',mini=True)\n        Traceback (most recent call last):\n        ...\n        ValueError: Desired database (='should not exist') does not exist\n        sage: c = CremonaDatabase('should not exist',mini=False)\n        Traceback (most recent call last):\n        ...\n        ValueError: Desired database (='should not exist') does not exist\n        sage: from sage.env import SAGE_SHARE\n        sage: os.path.isfile(os.path.join(SAGE_SHARE,'cremona','should_not_exist.db'))\n        False\n    \"\"\"\n    global _db\n    if set_global is None:\n        set_global = _db is None and name is None\n    if name is None and not set_global:\n        return _db\n    if set_global and name is None:\n        if is_package_installed('database_cremona_ellcurve'):\n            name = 'cremona'\n        else:\n            name = 'cremona mini'\n    if name == 'cremona':\n        mini = False\n    elif name == 'cremona mini':\n        mini = True\n    if mini is None:\n        raise ValueError('mini must be set as either True or False')\n    if set_global:\n        if mini:\n            _db = MiniCremonaDatabase(name)\n        else:\n            _db = LargeCremonaDatabase(name)\n        return _db\n    if mini:\n        return MiniCremonaDatabase(name)\n    return LargeCremonaDatabase(name)\n", "meta": {"hexsha": "0a5f79478a535a81d319a39fa5d90cafc69f2214", "size": 58592, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/databases/cremona.py", "max_stars_repo_name": "fredstro/sage", "max_stars_repo_head_hexsha": "c936d2cda81ec7ec3552a3bdb29c994b40d1bb24", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/sage/databases/cremona.py", "max_issues_repo_name": "fredstro/sage", "max_issues_repo_head_hexsha": "c936d2cda81ec7ec3552a3bdb29c994b40d1bb24", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/databases/cremona.py", "max_forks_repo_name": "fredstro/sage", "max_forks_repo_head_hexsha": "c936d2cda81ec7ec3552a3bdb29c994b40d1bb24", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.5064782097, "max_line_length": 139, "alphanum_fraction": 0.5708117149, "include": true, "reason": "import sage,from sage", "num_tokens": 15489, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3812195803163618, "lm_q2_score": 0.1403362530854946, "lm_q1q2_score": 0.053498927504422984}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Advanced Binary Image Segmentation for the Geo- and Eco-sciences, using Deep Learning\n# \n# ## Case Study: Detecting Intertidal Reefs\n# \n# #### Daniel Buscombe, MARDA Science\n# \n# ![](https://mardascience.com/wp-content/uploads/2019/06/cropped-MardaScience_logo-5.png)\n\n# Before you do anything, go to `File > Save copy in Drive` so you can keep and work on your own copy\n# \n# ## Lesson 3: Getting ready to train a oyster reef masker (binary segmentation of intertidal shellfish reefs) with the \"OysterNet\" data set\n# \n# This jupyter notebook running on Google Colab is part of the \"Advanced Binary Image Segmentation for the Geo- and Eco-sciences, using Deep Learning\" course. The main course website can be accessed [here](https://mardascience.gitlab.io/binary_image_segmentation_for_geosciences/#/)\n# \n# In the previous lesson we made functions to read and pair image and label tiles from this data. In this lesson, we will start by repeating that process without the visualization steps\n# \n# Then we will construct, train and evaluate the model. In the [oysterNet paper](https://zslpublications.onlinelibrary.wiley.com/doi/full/10.1002/rse2.134), the authors used a bigger, more sophisticated model for `instance segmentation`, that is, semantic segmentation that is aware of all the different `instances` of the class (i.e. each individual piece of reef). The model they use is called `Mask RCNN`, the implementation of which is [here](https://github.com/matterport/Mask_RCNN). That is a large and very complicated model that is hard to experiment with. The research behind the [oysterNet paper](https://zslpublications.onlinelibrary.wiley.com/doi/full/10.1002/rse2.134) is state-of-the-art.\n# \n# Here, we use a simpler model with fewer parameters (namely, a residual UNet) and acheive acceptable results for a semantic segmentation (predicting the masks of where the reefs are, rather than by individual instances). The UNet is the same we used in a [previous set of tutorials](https://mardascience.gitlab.io/deep_learning_landscape_classification/#/) and is relatively simple to adapt and play with to demonstrate a few principles.\n# \n# Actually, in this tutorial we'll start with a basic implementation and get really bad results (!). This is designed to introduce you to the complicated workflow, but at the same time demonstrating a principle: use an appropriate loss function to train your model - one that isn't sensitive to class imbalance. We talk about what that means as we go\n# \n# This is designed to demonstrate a problem-solving strategy, and also a principle that often applies to natural imagery:\n# \n# > It's not just the model you choose, it's how you train it that counts\n\n# ### Import libraries\n\n# In[ ]:\n\n\nimport os #for accessing operating system utilities\nfrom glob import glob #for finding files that match a certain string pattern\nimport matplotlib.pyplot as plt #for plotting\nimport numpy as np #for numerical operations\nimport random, string #for creating random strings\nimport tensorflow as tf #tensorflow\nimport json # for reading lable annotations in json format\nimport requests #for downloading files \nfrom PIL import Image, ImageFilter #for reading and filtering imagery\nimport skimage.draw #for making masks (raster label images) from label annotations\nfrom skimage.transform import resize #for resizing imagery\nfrom psutil import virtual_memory #for interrogating our filesystem and RAM specifications\nfrom imageio import imwrite\n\n\n# ### Prepare the data\n\n# #### Download the JSON annotations and imagery\n# \n# If you followed the previous lesson, you'll see that we downloaded the dataset consisting of three large (spatially extensive) orthomosaics, split that data into 555 tiles and labels, and visualize those data\n# \n# Because this lesson assumes you are running this notebook on Google Colab, we'll have to download and split the data again before training a model. This time we'll do it without the commentary. If you need a recap, see the previous lesson\n\n# In[ ]:\n\n\n# from https://stackoverflow.com/questions/38511444/python-download-files-from-google-drive-using-url\n\ndef download_file_from_google_drive(id, destination):\n    URL = \"https://docs.google.com/uc?export=download\"\n\n    session = requests.Session()\n\n    response = session.get(URL, params = { 'id' : id }, stream = True)\n    token = get_confirm_token(response)\n\n    if token:\n        params = { 'id' : id, 'confirm' : token }\n        response = session.get(URL, params = params, stream = True)\n\n    save_response_content(response, destination)    \n\ndef get_confirm_token(response):\n    for key, value in response.cookies.items():\n        if key.startswith('download_warning'):\n            return value\n\n    return None\n\ndef save_response_content(response, destination):\n    \"\"\"\n    response = filename for input\n    destination = filename for output\n    \"\"\"    \n    CHUNK_SIZE = 32768\n\n    with open(destination, \"wb\") as f:\n        for chunk in response.iter_content(CHUNK_SIZE):\n            if chunk: # filter out keep-alive new chunks\n                f.write(chunk)\n\n\n# In[ ]:\n\n\n## if you are doing this for the second time, you'll want to delete the files first\n# !rm -rf 1kx1k_dataset\n# !rm 1kx1k_dataset.zip\n\n\n# In[ ]:\n\n\nfile_id = '1gJq3J8CpXZqLGgUeOU7rXRGEq9glOMmI'\ndestination = '1kx1k_dataset.zip'\ndownload_file_from_google_drive(file_id, destination)\n\n\n# In[ ]:\n\n\nget_ipython().system('unzip 1kx1k_dataset.zip > tmp.txt')\n\n\n# In[ ]:\n\n\ndata_dir = \"1kx1k_dataset/test\"\ntest_annotations = json.load(open(os.path.join(data_dir, \"via_region_data.json\")))\ntest_annotations = list(test_annotations.values()) \n\n\n# In[ ]:\n\n\ndata_dir = \"1kx1k_dataset/train\"\ntrain_annotations = json.load(open(os.path.join(data_dir, \"via_region_data.json\")))\ntrain_annotations = list(train_annotations.values()) \n\n\n# In[ ]:\n\n\ndata_dir = \"1kx1k_dataset/val\"\nval_annotations = json.load(open(os.path.join(data_dir, \"via_region_data.json\")))\nval_annotations = list(val_annotations.values()) \n\n\n# In[ ]:\n\n\nprint(\"# test files: %i\" % (len(test_annotations)))\nprint(\"# train files: %i\" % (len(train_annotations)))\nprint(\"# validation files: %i\" % (len(val_annotations)))\n\n\n# #### Visualize\n\n# In[ ]:\n\n\na = test_annotations[50]\n\nim = Image.open(os.path.join(data_dir, a['filename']))\n\n\n# In[ ]:\n\n\nplt.figure(figsize=(16,16))\nplt.subplot(121)\nplt.imshow(np.array(im))\nplt.axis('off')\nplt.title('Original')\n\nplt.subplot(122)\nim = im.filter(ImageFilter.UnsharpMask(radius=5, percent=200, threshold=3))\nplt.imshow(np.array(im))\nplt.axis('off')\nplt.title('Filtered')\n\n\n# #### Augment\n\n# Augmentation isn't just about increasing the size of the dataset. In fact its main function is to give the model greater variability so it can generalize better (i.e. it is a regularization strategy). We will create zoomed in and zoomed out copies of the imagery, with random rotations and flips. This will give the model more opportunity to develop a scale and rotation invariant image feature extraction solution\n# \n# This is going to be a lot easier if both images and labels exist in image formats. That way, we can use keras' built-in augmentation functions. Currently, the labels are still in json format\n# \n# So, the first thing we do is write out all the labels in jpg format, for both training and validation sets\n# \n# Then, we make a new directory to store those labels and move them in there\n# \n# Finally, we make an assoiated image directory and copy the images associated with each of the labels in its own directory\n# \n# We'll need a function to get every image and label like we did in the previous tutorial\n# \n\n# In[ ]:\n\n\ndef get_image_mask_pair(a, sz):\n\n  if type(a['regions']) is dict:\n      polygons = [r['shape_attributes'] for r in a['regions'].values()]\n  else:\n      print('in the dict type')\n      polygons = [r['shape_attributes'] for r in a['regions']]\n\n  image_path = os.path.join(data_dir, a['filename'])\n  #image = skimage.io.imread(image_path)\n  image = Image.open(image_path)\n\n  image = image.filter(ImageFilter.UnsharpMask(radius=5, percent=200, threshold=3))\n\n  height, width = np.array(image).shape[:2]\n\n  # Convert polygons to a bitmap mask of shape\n  # [height, width, number of polygons]\n  info = a['filename']\n  mask = np.zeros([height, width, len(polygons)],dtype=np.uint8)\n\n  for i, p in enumerate(polygons):\n      # Get indexes of pixels inside the polygon and set them to 1\n      rr, cc = skimage.draw.polygon(p['all_points_y'], p['all_points_x'])\n      mask[rr, cc, i] = 1\n\n  mask = mask.astype(np.int) #, np.ones([mask.shape[-1]], dtype=np.int)\n  mask = np.sum(mask, axis=2)\n\n  if np.sum(np.isnan(mask))==(sz[0]*sz[1]):\n      print(info)\n\n  image = np.array(image.resize(sz))/255.\n  mask = resize(mask, sz)\n\n  mask = (mask-mask.min())/(mask.max()-mask.min()) #*255.\n\n  return image, mask\n\n\n# Get the training set and write them to file\n\n# In[ ]:\n\n\nroot = './'\n\n\n# In[ ]:\n\n\n# train set\nfor t in train_annotations:\n   _, mask = get_image_mask_pair(t, ((1000,1000)))\n   imwrite(root+\"1kx1k_dataset\"+t['filename'].replace('.png', '.jpg').replace('../','/'), mask)\n\n\n# make a new directory called `train_labels` and move all the jpgs we just made there\n\n# In[ ]:\n\n\ntry:\n    os.mkdir(root+\"1kx1k_dataset/train_labels\")\nexcept:\n    pass\nos.system(\"mv \"+root+\"1kx1k_dataset/*.jpg \"+root+\"1kx1k_dataset/train_labels\")\n\n\n# Get a list of those files\n\n# In[ ]:\n\n\ntrain_label_names = sorted(glob(root+\"1kx1k_dataset/train_labels/*.jpg\"))\n\ntrain_image_names = [l.replace('.jpg','.png').replace('train_labels/', '') for l in train_label_names]\n\n\n# Do the same thing as the above but for the RGB imagery\n\n# In[ ]:\n\n\ntry:\n    os.mkdir(root+\"1kx1k_dataset/train_images\")\nexcept:\n    pass\nfor k in train_image_names:\n   os.system(\"cp \"+k+\" \"+root+\"1kx1k_dataset/train_images\")\n\n\n# Do the same for the validation subset\n\n# In[ ]:\n\n\n# validation\nfor t in val_annotations:\n   _, mask = get_image_mask_pair(t, ((1000,1000)))\n   imwrite(root+\"1kx1k_dataset\"+t['filename'].replace('.png', '.jpg').replace('../','/'), mask)\n\ntry:\n    os.mkdir(root+\"1kx1k_dataset/val_labels\")\nexcept:\n    pass\nos.system(\"mv \"+root+\"1kx1k_dataset/*.jpg \"+root+\"1kx1k_dataset/val_labels\")\n\nval_label_names = sorted(glob(root+\"1kx1k_dataset/val_labels/*.jpg\"))\n\nval_image_names = [l.replace('.jpg','.png').replace('val_labels/', '') for l in val_label_names]\n\ntry:\n    os.mkdir(root+\"1kx1k_dataset/val_images\")\nexcept:\n    pass\nfor k in val_image_names:\n   os.system(\"cp \"+k+\" \"+root+\"1kx1k_dataset/val_images\")\n\n\n# Finally, do the same for the test subset\n\n# In[ ]:\n\n\n# test\nfor t in test_annotations:\n   _, mask = get_image_mask_pair(t, ((1000,1000)))\n   imwrite(root+\"1kx1k_dataset\"+t['filename'].replace('.png', '.jpg').replace('../','/'), mask)\n\ntry:\n    os.mkdir(root+\"1kx1k_dataset/test_labels\")\nexcept:\n    pass\nos.system(\"mv \"+root+\"1kx1k_dataset/*.jpg \"+root+\"1kx1k_dataset/test_labels\")\n\nval_label_names = sorted(glob(root+\"1kx1k_dataset/test_labels/*.jpg\"))\n\nval_image_names = [l.replace('.jpg','.png').replace('test_labels/', '') for l in val_label_names]\n\ntry:\n    os.mkdir(root+\"1kx1k_dataset/test_images\")\nexcept:\n    pass\nfor k in val_image_names:\n   os.system(\"cp \"+k+\" \"+root+\"1kx1k_dataset/test_images\")\n\n\n# Next to augmentation. We'll be using the `flow_from_directory` option of the `tf.keras.preprocessing.image.ImageDataGenerator`\n# function, which will allow us to feed our existing training files into a generator to  augment each image using a random combination of transformations\n# \n# Now, a quirk of `flow_from_directory` is that it expects imagery from each class to be in its own subdirectory of the directory you point it to. So, we create one subdirectory in each of the 4 folders we created just now called 'data', and move the files into it\n\n# In[ ]:\n\n\nos.mkdir(root+\"1kx1k_dataset/val_images/data\")\nos.mkdir(root+\"1kx1k_dataset/train_images/data\")\nos.mkdir(root+\"1kx1k_dataset/val_labels/data\")\nos.mkdir(root+\"1kx1k_dataset/train_labels/data\")\n\nos.system(\"mv \"+root+\"1kx1k_dataset/val_images/*.png \"+root+\"1kx1k_dataset/val_images/data\")\nos.system(\"mv \"+root+\"1kx1k_dataset/train_images/*.png \"+root+\"1kx1k_dataset/train_images/data\")\nos.system(\"mv \"+root+\"1kx1k_dataset/val_labels/*.jpg \"+root+\"1kx1k_dataset/val_labels/data\")\nos.system(\"mv \"+root+\"1kx1k_dataset/train_labels/*.jpg \"+root+\"1kx1k_dataset/train_labels/data\")\n\n\n# We'll use random combinations of vertical and horizontal flips, zoom in/out up to 30% and up to +/- 10 deg. rotations. Boundaries are mirrored for a more natural look\n\n# In[ ]:\n\n\ndatagen = tf.keras.preprocessing.image.ImageDataGenerator(\n        featurewise_center=False,\n        featurewise_std_normalization=False,\n        zoom_range=0.3,\n        vertical_flip = True,\n        rotation_range=10,\n        horizontal_flip=True,\n        fill_mode='reflect')\n\nimg_generator = datagen.flow_from_directory(\n        root+\"1kx1k_dataset/train_images\",\n        target_size=(1000, 1000),\n        batch_size=1,\n        class_mode=None, seed=2020, shuffle=False)\n\nmask_generator = datagen.flow_from_directory(\n        root+\"1kx1k_dataset/train_labels\",\n        target_size=(1000, 1000),\n        batch_size=1,\n        class_mode=None, seed=2020, shuffle=False)\n\ntrain_generator = (pair for pair in zip(img_generator, mask_generator))\n\n\n# Write them to file\n\n# In[ ]:\n\n\nimport matplotlib\n\n\n# In[ ]:\n\n\nn_aug_files = len(train_annotations)\n\ntrain_generator2 = (tuple(np.array(pair, dtype='float64')/255) for pair in zip(img_generator, mask_generator))\n\ncounter = 0\nwhile counter<n_aug_files:\n    x, y = next(train_generator2)\n    matplotlib.image.imsave(root+\"1kx1k_dataset/train_labels/data/aug00\"+str(counter)+\".jpg\", np.squeeze(y[0]))\n    matplotlib.image.imsave(root+\"1kx1k_dataset/train_images/data/aug00\"+str(counter)+\".png\", np.squeeze(x[0]))\n    counter += 1\n\n\n# Check to see how many images we now have to work with\n\n# In[ ]:\n\n\ntrain_files = glob(root+\"1kx1k_dataset/train_images/data/*.png\")\nval_files = glob(root+\"1kx1k_dataset/val_images/data/*.png\")\n\nprint(\"# train files: %i\" % (len(train_files)))\nprint(\"# validation files: %i\" % (len(val_files)))\n\n\n# Previously we have 527 train files. Now we have 1054\n\n# ## Custom batch generator\n\n# In[ ]:\n\n\ndef image_batch_generator(files, sz, batch_size = 4):\n\n  while True: # this is here because it will be called repeatedly by the training function\n\n    #extract a random subset of files of length \"batch_size\"\n    batch = np.random.choice(files, size = batch_size)\n\n    #variables for collecting batches of inputs (x) and outputs (y)\n    batch_x = []\n    batch_y = []\n\n    #cycle through each image in the batch\n    for f in batch:\n\n        #preprocess the raw images\n        raw = Image.open(f)\n        raw = raw.resize(sz)\n        raw = raw.filter(ImageFilter.UnsharpMask(radius=20, percent=100)) #apply the unsharp filter\n        raw = np.array(raw)\n\n        #check the number of channels because some of the images are RGBA or GRAY\n        if len(raw.shape) == 2:\n            raw = np.stack((raw,)*3, axis=-1)\n\n        else:\n            raw = raw[:,:,0:3]\n\n        #get the image dimensions, find the min dimension, then square the image off\n        nx, ny, nz = np.shape(raw)\n        n = np.minimum(nx,ny)\n        raw = raw[:n,:n,:]\n\n        raw[np.isnan(raw)] = 1e-5 #turn bad values (nans and infs) into tiny numbers\n        raw[np.isinf(raw)] = 1e-5\n\n        batch_x.append(raw)\n\n        #get the masks.\n        maskfile = f.replace('_images','_labels').replace('.png','.jpg')\n        mask = Image.open(maskfile)\n        # the mask is 3-dimensional so get the max in each channel to flatten to 2D\n        try:\n           mask = np.max(np.array(mask.resize(sz)),axis=2)\n        except:\n           mask = np.array(mask.resize(sz))\n\n        # class pixels are greater than 170\n        mask = (mask>170).astype('int') ##170 = (2/3)*255\n\n        mask = mask[:n,:n]\n\n        mask[np.isnan(mask)] = 1e-5\n        mask[np.isinf(mask)] = 1e-5\n        batch_y.append(mask)\n\n    #preprocess a batch of images and masks\n    batch_x = np.array(batch_x) #/255. #divide image by 255 to normalize\n    batch_y = np.array(batch_y)\n    batch_y = np.expand_dims(batch_y,1) #add singleton dimension to batch_y\n\n    yield (batch_x, batch_y) #yield both the image and the label together\n\n\n# In[ ]:\n\n\nsz = (1024, 1024)\n\ngen = image_batch_generator(train_files, sz, batch_size = 4)\n\nimages, masks = next(gen)\n\nplt.figure(figsize=(10,10))\nplt.imshow(images[0])\nplt.imshow(masks[0].squeeze(), alpha=0.25, cmap=plt.cm.Reds)\n\n\n# \n\n# In[ ]:\n\n\nget_ipython().system('tar -czf train_images.tar.gz /content/1kx1k_dataset/train_images')\n\n\n# Do the same for the train labels, validation images and validation labels\n\n# In[ ]:\n\n\nget_ipython().system('tar -czf train_labels.tar.gz /content/1kx1k_dataset/train_labels')\n\n\n# In[ ]:\n\n\nget_ipython().system('tar -czf val_images.tar.gz /content/1kx1k_dataset/val_images')\n\n\n# In[ ]:\n\n\nget_ipython().system('tar -czf val_labels.tar.gz /content/1kx1k_dataset/val_labels')\n\n\n# finally the test set\n\n# In[ ]:\n\n\nget_ipython().system('tar -czf test_images.tar.gz /content/1kx1k_dataset/test_images')\nget_ipython().system('tar -czf test_labels.tar.gz /content/1kx1k_dataset/test_labels')\n\n\n# For the remainder of the tutorials, we'll be using this version of the data, consisting of imagery and image labels, with an augmented training set consisting of double the original number of imagery, half of which have been augmented with random flips, zoms and rotations\n\n# This jupyter notebook running on Google Colab is part of the \"Advanced Binary Image Segmentation for the Geo- and Eco-sciences, using Deep Learning\" course. The main course website can be accessed [here](https://mardascience.gitlab.io/binary_image_segmentation_for_geosciences/#/)\n# \n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "5947696517df955a7aa75cb06d1e0bbd22b77b42", "size": 17792, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/Oyster_reefs/Part2_Getting_Ready_for_Training.py", "max_stars_repo_name": "MARDAScience/UNets4IntertidalReefs", "max_stars_repo_head_hexsha": "551c22e29bafe6b01686a833aa881be2b52b6a2a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "scripts/Oyster_reefs/Part2_Getting_Ready_for_Training.py", "max_issues_repo_name": "MARDAScience/UNets4IntertidalReefs", "max_issues_repo_head_hexsha": "551c22e29bafe6b01686a833aa881be2b52b6a2a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scripts/Oyster_reefs/Part2_Getting_Ready_for_Training.py", "max_forks_repo_name": "MARDAScience/UNets4IntertidalReefs", "max_forks_repo_head_hexsha": "551c22e29bafe6b01686a833aa881be2b52b6a2a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.9425493716, "max_line_length": 702, "alphanum_fraction": 0.7127360612, "include": true, "reason": "import numpy", "num_tokens": 4600, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3380771241500058, "lm_q2_score": 0.1581743547325992, "lm_q1q2_score": 0.053475130962279994}}
{"text": "'''\nDate: 29 October 2017\n@authors: Apurba Sengupta\n\n'''\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport time, re\nfrom sklearn.feature_extraction.text import CountVectorizer\nfrom scipy import sparse, interpolate\n\nstart_time1 = time.time()\n\n# **********************************************************************************************\n#\n#   function definitions\n#    \n# **********************************************************************************************\n    \n\ndef loadTrainData(filename):\n\n    '''\n    Question 1.1\n\n    For the first part you are required to download the Sentiment140 dataset found\n    here (http://cs.stanford.edu/people/alecmgo/trainingandtestdata.zip). Unzip the \n    file and read in the CSV with training data (it has 1.6 million entries). The   \n    file contains a table of Sentiment, UserID, Date, no-query, user id, the actual\n    tweet. Read in only the sentiment and the tweet. You are welcome to use other \n    values as additional features. Sentiment in the data file is classified as\n    either 0 (negative emotion) or 4 (positive emotion). Convert these to -1 and 1\n    respectively.\n\n    '''\n\n    print \"\\n Loading the training data ... \"\n\n    # read the data into a pandas DataFrsme object and convert it into a NumPy matrix\n    train_data_matrix = np.array(pd.read_csv(filename, header = None))\n\n    # the last column of the matrix is the tweet, taken only upto the first comma in the tweet\n    X_train = np.array([tweet.split(',')[0] for tweet in train_data_matrix[:,-1]])\n\n    # the first column of the matrix is the sentiment (either 0 or 4)\n    Y_train = train_data_matrix[:,0]\n\n    # label the sentimnents with value 4 as 1\n    Y_train[Y_train==4] = 1\n\n    # label the sentiments with value 0 as -1\n    Y_train[Y_train==0] = -1\n\n    end_time1 = time.time() - start_time1\n    \n    print \"\\n Training data Loaded ...\"\n\n    print \"\\n Time taken to load the training data (in seconds) = \", end_time1\n\n    start_time2 = time.time()\n\n    '''\n    Question 1.2 : cleaning up the data \n    \n    Perform the following operations on each of the tweets.\n    1. Convert all letters into lowercase.\n    2. Convert all occurences of 'www.' or 'https://' or 'http://' to 'URL'.\n    3. Remove additional white spaces.\n    4. Remove all punctuation.\n    5. Replace @username with AT-USER.\n    6. Replace duplicate words - e.g. 'very very' should be replaced by 'very'.\n    7. After Steps 1-6 have been performed, check if the tweet has any of the words\n    from stopwords.txt (provided on Canvas). If there are any other words that are\n    stop words, ignore them. Whatever now remains of the original tweet is the \n    feature vector for that tweet. Create a table of feature vectors and sentiment.\n    For example for the first tweet in the dataset, which looks like \"@switchfoot\n    http://twitpic.com/2y1zl - Awww, that's a bummer. You shoulda got David Carr \n    of Third Day to do it. ;D\" the extracted feature is \"aww\". The second tweet \n    \"is upset that he can't update his Facebook by texting it... and might cry as a\n    result School today also. Blah!\" after doing steps 1-5 yields the features\n    ['upset', 'update', 'facebook', 'texting', 'cry', 'result', 'school']\n    \n    '''\n\n    print \"\\n\\n Cleaning the training data ... \\n\\n\"\n\n    # convert the tweets into String objects\n    X_train = X_train.astype(str)\n\n    print \"\\n Converting the tweets to lowercase ...\"\n\n    # 1. convert all the tweets into lowercase\n    X_train = np.core.defchararray.lower(X_train)\n    \n    print \"\\n Converting all occurences of 'www.', 'https://' and 'http://' to 'URL' ...\"\n\n    # 2. convert all occurences of 'www.','https://','http://' to 'URL'\n    X_train = np.array([re.sub(r'((http://)|(www.)|(https://))(?:[a-zA-Z]|[0-9]|[$-_~@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', 'URL', tweet) for tweet in X_train])\n    \n    print \"\\n Removing additional white spaces at beginning of text and in between text ...\"\n\n    # 3. remove additional white spaces at beginning of text and in between text\n    X_train = np.core.defchararray.strip(X_train)\n    X_train = np.core.defchararray.replace(X_train, '  ', ' ')\n\n    print \"\\n Removing all punctuation ...\"\n\n    # 4. remove all punctuation\n    X_train = np.array([re.sub(r'[!\"#$%&\\'\\(\\)*+,-./:;<=>?\\[\\\\\\]^_`\\{|\\}~]', '', tweet) for tweet in X_train])\n\n    print \"\\n Converting all occurances of '@<username>' to 'AT-USER' ...\"\n\n    # 5. convert all occurances of @username to 'AT-USER'\n    X_train = np.array([re.sub(r'(@)(?:[a-zA-Z]|[0-9])+', 'AT-USER', tweet) for tweet in X_train])             \n    \n    print \"\\n Replacing consecutive duplicate words with a single occurance of the word ...\"\n\n    # 6. replace consecutive duplicate words with a single occurance\n    X_train = np.array([re.sub(r'\\b(\\w+)(\\s\\1\\b)+', r'\\1', tweet) for tweet in X_train])\n\n    print \"\\n Removing stop words ...\"\n\n    # 7. remove stop words\n    with open(r\"stopwords.txt\", 'r') as stopWordsFile:\n        wordList = stopWordsFile.read().split('\\n')\n        regex = re.compile(r'\\b(%s)\\b' % '|'.join(wordList))\n        X_train = np.array([re.sub(regex, ' ', tweet) for tweet in X_train])\n\n    print \"\\n\\n Cleaned the training data ...\\n\\n\"\n    \n    '''\n    Question 1.3\n\n    Extract unigram features from the bag of words. The bag of words here is the \n    set of all words collected after performing steps 1-6. You are free to use any\n    library to create unigram features from the bag of words. To give an example \n    (from wikipedia) : Consider we have the tweets \"John likes to watch movies. \n    Mary likes movies too.\" and the tweet \"John also likes to watch football \n    games\". The bag of words (Steps 1-6) gives us (John,likes,to,watch,movies,Mary,\n    too,also,football,games.) To now extract unigram features, in the tweet \"John \n    likes to watch movies. Mary likes movies too.\" count the number of times each \n    word appears in the bag of words. Thus, the feature vector would look like \n    [1, 2, 1, 1, 2, 1, 1, 0, 0, 0]. John occurs once in the tweet, likes occurs \n    twice and so on. For more detail see the wikipedia article on bag of words. \n    You are free to extract bi-gram/n-gram features. Thus, at the end of this you \n    should have a list of features and the sentiment attached to these features.\n\n    '''\n\n    print \"\\n Creating bags-of-words (BoW) of the features ...\"\n\n    # generate bags-of-words (BoW) of the features\n    X_train = np.core.defchararray.split(X_train)\n    train_bags_of_words = np.array([list(set(tweetWords)) for tweetWords in X_train]) \n\n    print \"\\n BoW of the features created ...\"\n\n    print \"\\n\\n Creating table of BoW of features and corresponding sentiments ...\\n\\n\"\n\n    # generate table of BoW of features and corresponding sentiments\n    data_table = pd.DataFrame(train_bags_of_words, columns = ['Features'])\n    data_table['Sentiments'] = Y_train\n    print \"\\n\", data_table\n\n    end_time2 = time.time() - start_time2\n\n    print \"\\n\\n Table of BoW of features and corresponding sentiments created ...\"\n\n    print \"\\n\\n Time taken to clean the training data to form table of BoW of features and corresponding sentiments (in seconds) = \", end_time2\n\n    return X_train, Y_train\n\ndef loadTestData(filename):\n\n    start_time6 = time.time()\n\n    '''\n    Question 1.6\n\n    Read in the test CSV dataset. Perform all steps in Question 1.1 and 1.2. An\n    additional step required is that the sentiments in the test set are 0, 2 and 4.\n    Convert the tweets with sentiment 2 to 4. Report test accuracy and a plot of \n    test error vs number of iterations for classfiers trained in Part 1.4 and Part 1.5.\n    \n    '''\n\n    print \"\\n\\n Loading the test data ... \"\n\n    # read the data into a pandas DataFrsme object and convert it into a NumPy matrix\n    test_data_matrix = np.array(pd.read_csv(filename, header = None))\n\n    # the last column of the matrix is the tweet, taken only upto the first comma in the tweet\n    X_test = np.array([tweet.split(',')[0] for tweet in test_data_matrix[:,-1]])\n\n    # the first column of the matrix is the sentiment (either 0 or 4)\n    Y_test = test_data_matrix[:,0]\n\n    # label the sentimnents with value 2 as 4\n    Y_test[Y_test==2] = 4\n    \n    # label the sentimnents with value 4 as 1\n    Y_test[Y_test==4] = 1\n\n    # label the sentiments with value 0 as -1\n    Y_test[Y_test==0] = -1\n\n    end_time6 = time.time() - start_time6\n    \n    print \"\\n Test data Loaded ...\"\n\n    print \"\\n\\n Time taken to load the test data (in seconds) = \", end_time6\n\n    start_time7 = time.time()\n    \n    print \"\\n\\n Cleaning the test data ... \\n\\n\"\n    \n    # convert the tweets into String objects\n    X_test = X_test.astype(str)\n    \n    print \"\\n\\n Converting the tweets to lowercase ...\"\n\n    # 1. convert all the tweets into lowercase\n    X_test = np.core.defchararray.lower(X_test)\n\n    print \"\\n Converting all occurences of 'www.', 'https://' and 'http://' to 'URL' ...\"\n\n    # 2. convert all occurences of 'www.','https://','http://' to 'URL'\n    X_test = np.array([re.sub(r'((http://)|(www.)|(https://))(?:[a-zA-Z]|[0-9]|[$-_~@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', 'URL', tweet) for tweet in X_test])\n\n    print \"\\n Removing additional white spaces at beginning of text and in between text ...\"\n\n    # 3. remove additional white spaces at beginning of text and in between text\n    X_test = np.core.defchararray.strip(X_test)\n    X_test = np.core.defchararray.replace(X_test, '  ', ' ')\n    \n    print \"\\n Removing all punctuation ...\"\n\n    # 4. remove all punctuation\n    X_test = np.array([re.sub(r'[!\"#$%&\\'\\(\\)*+,-./:;<=>?\\[\\\\\\]^_`\\{|\\}~]', '', tweet) for tweet in X_test])\n\n    print \"\\n Converting all occurances of '@<username>' to 'AT-USER' ...\"\n\n    # 5. convert all occurances of @username to 'AT-USER'\n    X_test = np.array([re.sub(r'(@)(?:[a-zA-Z]|[0-9])+', 'AT-USER', tweet) for tweet in X_test])             \n    \n    print \"\\n Replacing consecutive duplicate words with a single occurance of the word ...\"\n\n    # 6. replace consecutive duplicate words with a single occurance\n    X_test = np.array([re.sub(r'\\b(\\w+)(\\s\\1\\b)+', r'\\1', tweet) for tweet in X_test])\n\n    print \"\\n Removing stop words ...\"\n\n    # 7. remove stop words\n    with open(r\"stopwords.txt\", 'r') as stopWordsFile:\n        wordList = stopWordsFile.read().split('\\n')\n        regex = re.compile(r'\\b(%s)\\b' % '|'.join(wordList))\n        X_test = np.array([re.sub(regex, ' ', tweet) for tweet in X_test])\n\n    print \"\\n\\n Cleaned the test data ...\\n\\n\"\n\n    # get words of each tweet\n    X_test = np.core.defchararray.split(X_test)\n    \n    end_time7 = time.time() - start_time7\n\n    print \"\\n\\n Time taken to clean the test data (in seconds) = \", end_time7\n    \n    return X_test, Y_test\n\ndef createUnigramFeatureMatrixFromTweets(X_train, X_test):\n\n    start_time3 = time.time()\n    \n    '''\n    Question 1.3\n\n    Extract unigram features from the bag of words. The bag of words here is the \n    set of all words collected after performing steps 1-6. You are free to use any\n    library to create unigram features from the bag of words. To give an example \n    (from wikipedia) : Consider we have the tweets \"John likes to watch movies. \n    Mary likes movies too.\" and the tweet \"John also likes to watch football \n    games\". The bag of words (Steps 1-6) gives us (John,likes,to,watch,movies,Mary,\n    too,also,football,games.) To now extract unigram features, in the tweet \"John \n    likes to watch movies. Mary likes movies too.\" count the number of times each \n    word appears in the bag of words. Thus, the feature vector would look like \n    [1, 2, 1, 1, 2, 1, 1, 0, 0, 0]. John occurs once in the tweet, likes occurs \n    twice and so on. For more detail see the wikipedia article on bag of words. \n    You are free to extract bi-gram/n-gram features. Thus, at the end of this you \n    should have a list of features and the sentiment attached to these features.\n\n    Question 1.5\n\n    Use AdaGrad to train a classifier on the features extracted above. Report a plot\n    of training error vs. number of iterations for every 1000 iterations. Merge this\n    plot with the one from the previous question. No libraries are allowed here.\n\n    '''\n\n    # encode the string entries as 'latin-1' and get back the preprocessed tweets\n    train_tweets_latin = np.array([[word.decode('latin-1') for word in tweet] for tweet in X_train])\n    preprocessed_tweet_corpus_train = [' '.join(tweet) for tweet in train_tweets_latin]\n\n    # encode the string entries as 'latin-1' and get back the preprocessed tweets\n    test_tweets_latin = np.array([[word.decode('latin-1') for word in tweet] for tweet in X_test])\n    preprocessed_tweet_corpus_test = [' '.join(tweet) for tweet in test_tweets_latin]\n    \n    # corpus of preprocessed tweets\n    preprocessed_tweet_corpus = preprocessed_tweet_corpus_train + preprocessed_tweet_corpus_test\n\n    print \"\\n\\n Creating unigram features and converting the data into a matrix of feature occurances ...\"\n\n    # convert the preprocessed tweets to a matrix of unigram feature counts\n    vectorizer = CountVectorizer(ngram_range = (1,1))\n    \n    # training set matrix\n    X_train_sparse = vectorizer.fit_transform(preprocessed_tweet_corpus)[:X_train.shape[0],:]\n    \n    # test set amtrix\n    X_test_sparse = vectorizer.fit_transform(preprocessed_tweet_corpus)[X_train.shape[0]:,:]\n\n    print \"\\n\\n Converted the data into training and test matrices of feature occurances ...\"\n\n    end_time3 = time.time() - start_time3\n\n    print \"\\n\\n Time taken to construct the training and test set matrices (in seconds) = \", end_time3\n\n    return X_train_sparse, X_test_sparse\n\ndef runPegasosAndAdaGrad(X_train_sparse, Y_train):\n\n    start_time4 = time.time()\n\n    '''\n    Question 1.4\n\n    Use PEGASOS to train an SVM on the features extracted above. Make a plot of\n    training error v/s number of iterations.\n\n    '''\n\n    # **************************************************************************************************\n    #\n    #                       PEGASOS - Primal Estimated sub-GrAdient SOlver for SVM \n    #\n    #   Input : Training Set S = {(x1, y1), (x2, y2), ....., (xn, yn)}, Regularization parameter lambda,\n    #           Number of iterations = T  \n    #\n    #   Initialize : w such that norm(w) <= 1/sqrt(lambda)\n    #\n    #   For t = 1, 2, ..., T:\n    #\n    #       1. Choose A (a randomly chosen subset of S) with |A| = B\n    #\n    #       2. A+ = {(x,y) (present in A) such that y<w,x> < 1}\n    #\n    #       3. learning rate = eta = 1/(count * lambda)   \n    #\n    #       4. gradient = lambda * w - (eta / B) * <y,x> for (x,y) in A+\n    #\n    #       5. new w = w - eta * gradient\n    #\n    #       6. projection of new w = new w * min(1, 1/(sqrt(lambda) * norm(new w))\n    #\n    # **************************************************************************************************\n\n    print \"\\n\\n\\n\\n Running PEGASOS on the training data ...\\n\"\n\n    # set number of iterations\n    T_P = 5000\n\n    # set lambda (regularizer)\n    regularizer_P = 0.00001\n\n    # set number of random rows to be selected at every iteration\n    B_P = 1000\n\n    # initialize count\n    count_P = 1\n\n    # initialize decision boundary\n    w_P = np.zeros(X_train_sparse.shape[1])\n\n    # initial prediction\n    Y_pred_P = X_train_sparse.dot(w_P)\n\n    # initial training error\n    training_error_P = float(np.logical_xor((Y_pred_P > 0).astype(int), (Y_train.astype(int) > 0).astype(int)).sum())/float(X_train_sparse.shape[0])\n\n    # lsit to hold training error2\n    training_error_list_P = [training_error_P]\n\n    # list to hold number of iterations\n    count_list_P = [count_P]\n    \n    # list to hold the decision values for each iteration\n    w_P_list = [w_P]\n    \n    for i in range(T_P):\n    \n        # randomly generate B_P row numbers\n        j = np.random.randint(0, X_train_sparse.shape[0] , B_P)\n        \n        # generate the corresponding random subsets of X_train_sparse and Y_train \n        x_P = X_train_sparse[j]\n        y_P = Y_train[j].astype(int)\n    \n        # compute the learning rate\n        eta_P = 1/float(count_P * regularizer_P)\n    \n        # see the sign of y<w,x> and generate a binary decision vector after checking if y<w,x> < 1 \n        decision_vector_P = np.multiply(x_P.dot(w_P), y_P)  \n        decision_vector_P = (decision_vector_P < 1).astype(int)\n    \n        # convert decision vector to a sparse CSR vector\n        decision_vector_sparse_P = sparse.csr_matrix(decision_vector_P).T\n        \n        # filter training examples for which y<w,x> >= 1\n        x_new_P = x_P.multiply(decision_vector_sparse_P)\n        y_new_P = np.multiply(y_P, decision_vector_P)\n    \n        # compute the gradient\n        grad_P = np.subtract(np.multiply(w_P, regularizer_P), np.multiply(x_new_P.T.dot(y_new_P), float(eta_P)/float(B_P)))\n    \n        # compute new decision boundary\n        w_new_P = np.subtract(w_P, np.multiply(grad_P, eta_P))\n    \n        # take projection of decision boundary so that it does not exit the set 1/srqt(regularizer_P)\n        w_new_proj_P = np.multiply(w_new_P, min(1, 1/(float(np.sqrt(regularizer_P)) *  float(np.linalg.norm(w_new_P)))))\n    \n        # increment the counter and put it in count_list\n        count_P = count_P + 1\n        count_list_P.append(count_P)\n        \n        # decision boundary is new decision boundary, put it in w_P_list\n        w_P = w_new_proj_P\n        w_P_list.append(w_P)\n        \n        # calculate training error and put it in training_error_list\n        y_pred_P = x_P.dot(w_P)\n        \n        training_error_P = float(np.logical_xor((y_pred_P > 0).astype(int), (y_P > 0).astype(int)).sum())/float(B_P)\n        training_error_list_P.append(training_error_P)\n    \n    print \"\\n\\n PEGASOS run successfully on the training data ...\\n\"\n\n    end_time4 = time.time() - start_time4\n\n    print \"\\n\\n Time taken to train data using PEGASOS (in seconds) = \", end_time4\n    \n    print \"\\n\\n\\n Plotting Training Error v/s Number of Iterations for the trained model for PEGASOS ...\\n\"\n\n    # plot training error v/s number of iterations\n    plt.title('\\n Training Error v/s Number of Iterations\\n')\n    plt.xlabel('Number of Iterations')\n    plt.ylabel('Training Error')\n    plt.plot(count_list_P, training_error_list_P, color = '#e0ffff')\n    tck1 = interpolate.splrep(count_list_P, training_error_list_P, k = 3, s = 900)\n    training_error_list_P_int = interpolate.splev(count_list_P, tck1, der = 0)\n    plt.plot(count_list_P, training_error_list_P_int, color = 'blue', label = 'PEGASOS')\n    plt.legend()\n    plt.show()\n\n    start_time5 = time.time()\n\n    '''\n    Question 1.5\n\n    Use AdaGrad to train a classifier on the features extracted above. Report a plot\n    of training error vs. number of iterations for every 1000 iterations. Merge this\n    plot with the one from the previous question. No libraries are allowed here.\n\n    '''\n\n    # **************************************************************************************************\n    #\n    #                                   AdaGrad - Adaptive Gradient \n    #\n    #   Input : Training Set S = {(x1, y1), (x2, y2), ....., (xn, yn)}, Regularization parameter lambda,\n    #           Number of iterations = T \n    #\n    #   Initialize : w such that norm(w) <= 1/sqrt(lambda), S old = (1,1,1.....,1)\n    #\n    #   For t = 1, 2, ..., T:\n    #\n    #       1. Choose A (a randomly chosen subset of S)\n    #\n    #       2. A+ = {(x,y) (present in A) such that y<w,x> < 1}\n    #\n    #       3. learning rate = eta = 0.01   \n    #\n    #       4. gradient = - <y,x> for (x,y) in A+\n    #\n    #       5. S new = S old + gradient^2\n    #\n    #       6. new w = w - [eta / (B * sqrt(S new))] * gradient\n    #   \n    #       7. projection of new w = new w * min(1, 1/(sqrt(lambda) * norm(S new * new w))\n    #\n    # **************************************************************************************************\n\n    print \"\\n\\n\\n\\n Running AdaGrad on the training data ...\\n\"\n\n    # set number of iterations\n    T_A = 5000\n\n    # set lambda (regularizer)\n    regularizer_A = 0.005\n\n    # set number of random rows to be selected at every iteration\n    B_A = 1000\n    \n    # set the learning rate\n    eta_A = 0.01\n    \n    # initialize count\n    count_A = 1\n\n    # initialize decision boundary\n    w_A = np.zeros(X_train_sparse.shape[1])\n\n    # initialize vector of diagonal elements of tranformation matrix G\n    S_A = np.ones(X_train_sparse.shape[1])\n\n    # initial prediction\n    Y_pred_A = X_train_sparse.dot(w_A)\n\n    # initial training error\n    training_error_A = float(np.logical_xor((Y_pred_A > 0).astype(int), (Y_train.astype(int) > 0).astype(int)).sum())/float(X_train_sparse.shape[0])\n\n    # lsit to hold training error2\n    training_error_list_A = [training_error_A]\n\n    # list to hold number of iterations\n    count_list_A = [count_A]\n    \n    # list to hold the decision values for each iteration\n    w_A_list = [w_A]\n\n    for i in range(T_A):\n        \n        # randomly generate B_A row numbers\n        j = np.random.randint(0, X_train_sparse.shape[0], B_A)\n    \n        # generate the corresponding random subsets of X_train_sparse and Y_train \n        x_A = X_train_sparse[j]\n        y_A = Y_train[j].astype(int)\n        \n        # see the sign of y<w,x> and generate a binary decision vector after checking if y<w,x> < 1 \n        decision_vector_A = np.multiply(x_A.dot(w_A), y_A)  \n        decision_vector_A = (decision_vector_A < 1).astype(int)\n        \n        # convert decision vector to a sparse CSR vector\n        decision_vector_sparse_A = sparse.csr_matrix(decision_vector_A).T\n        \n        # filter training examples for which y<w,x> >= 1\n        x_new_A = x_A.multiply(decision_vector_sparse_A)\n        y_new_A = np.multiply(y_A, decision_vector_A)\n    \n        # compute the gradient\n        grad_A = np.multiply((x_new_A.T.dot(y_new_A)), -1)\n    \n        # compute new vector of diagonal elements of tranformation matrix G\n        S_new_A = np.add(S_A, np.square(grad_A))\n    \n        # compute new decision boundary\n        w_new_A = np.subtract(w_A, np.multiply(grad_A, np.multiply(float(eta_A)/float(B_A), np.divide(1, np.sqrt(S_new_A)))))\n    \n        # take projection of decision boundary so that it does not exit the set 1/srqt(regularizer_A)\n        w_new_proj_A = np.multiply(w_new_A, min(1, 1/(float(np.sqrt(regularizer_A)) *  float(np.linalg.norm(np.multiply(S_new_A, w_new_A))))))\n    \n        # increment the counter and put it in count_list\n        count_A = count_A + 1\n        count_list_A.append(count_A)\n    \n        # decision boundary is new decision boundary, put it in w_A_list\n        w_A = w_new_proj_A\n        w_A_list.append(w_A)\n        \n        # vector of diagonal elements of tranformation matrix G is the new vector of diagonal elements of G\n        S_A = S_new_A\n    \n        # calculate training error and put it in training_error_list\n        y_pred_A = x_A.dot(w_A)\n    \n        training_error_A = float(np.logical_xor((y_pred_A > 0).astype(int), (y_A > 0).astype(int)).sum())/float(B_A)\n        training_error_list_A.append(training_error_A)\n\n    print \"\\n\\n AdaGrad ran successfully on the training data ...\\n\"\n\n    end_time5 = time.time() - start_time5\n\n    print \"\\n\\n Time taken to train data using AdaGrad (in seconds) = \", end_time5\n    \n    print \"\\n\\n\\n Plotting Training Error v/s Number of Iterations for the trained model for AdaGrad ...\\n\"\n\n    # plot training error v/s number of iterations\n    plt.title('\\n Training Error v/s Number of Iterations\\n')\n    plt.xlabel('Number of Iterations')\n    plt.ylabel('Training Error')\n    plt.plot(count_list_A, training_error_list_A, color = '#ffe4e1')\n    tck1 = interpolate.splrep(count_list_A, training_error_list_A, k = 3, s = 900)\n    training_error_list_A_int = interpolate.splev(count_list_A, tck1, der = 0)\n    plt.plot(count_list_A, training_error_list_A_int, color = 'red', label = 'AdaGrad')\n    plt.legend()\n    plt.show()\n    \n    print \"\\n\\n\\n Plotting Training Error v/s Number of Iterations for the trained model for PEGASOS and AdaGrad...\\n\"\n\n    # plot training error v/s number of iterations\n    plt.title('\\n Training Error v/s Number of Iterations\\n')\n    plt.xlabel('Number of Iterations')\n    plt.ylabel('Training Error')\n    plt.plot(count_list_P[::999], training_error_list_P_int[::999], color = 'blue', label = 'PEGASOS')\n    plt.plot(count_list_A[::999], training_error_list_A_int[::999], color = 'red', label = 'AdaGrad')\n    plt.legend()\n    plt.show()\n\n    return w_P_list, w_A_list, count_list_P, count_list_A\n\ndef testAccuracies(X_test_sparse, Y_test, w_P_list, w_A_list, count_list_P, count_list_A):\n    \n    '''\n    Question 1.6\n\n    Read in the test CSV dataset. Perform all steps in Question 1.1 and 1.2. An\n    additional step required is that the sentiments in the test set are 0, 2 and 4.\n    Convert the tweets with sentiment 2 to 4. Report test accuracy and a plot of \n    test error vs number of iterations for classfiers trained in Part 1.4 and Part 1.5.\n    \n    '''\n    \n    print \"\\n\\n\\n\\n Making predictions on the test data and calculating the classification accuracies ...\"\n\n    test_error_P = [float(np.logical_xor((X_test_sparse.dot(w_P) > 0).astype(int), (Y_test.astype(int) > 0).astype(int)).sum())/float(Y_test.shape[0]) for w_P in w_P_list] \n    \n    print \"\\n\\nPercentage Accuracy for PEGASOS: \" + str(round(100 - (test_error_P[-1] * 100), 3)) + \"%\"\n\n    test_error_A = [float(np.logical_xor((X_test_sparse.dot(w_A) > 0).astype(int), (Y_test.astype(int) > 0).astype(int)).sum())/float(Y_test.shape[0]) for w_A in w_A_list]\n\n    print \"\\n\\nPercentage Accuracy for AdaGrad: \" + str(round(100 - (test_error_A[-1] * 100), 3)) + \"%\"\n    \n    print \"\\n\\n\\n Plotting Test Error v/s Number of Iterations for the trained model for PEGASOS and AdaGrad...\\n\"\n    \n    # plot test error v/s number of iterations\n    plt.title('\\n Test Error v/s Number of Iterations\\n')\n    plt.xlabel('Number of Iterations')\n    plt.ylabel('Test Error')\n    plt.plot(count_list_P, test_error_P, color = '#e0ffff')\n    plt.plot(count_list_A, test_error_A, color = '#ffe4e1')\n    tck1 = interpolate.splrep(count_list_P, test_error_P, k = 3, s = 900)\n    test_error_P_int = interpolate.splev(count_list_P, tck1, der = 0)\n    tck2 = interpolate.splrep(count_list_A, test_error_A, k = 3, s = 900)\n    test_error_A_int = interpolate.splev(count_list_A, tck2, der = 0)\n    plt.plot(count_list_P, test_error_P_int, color = 'blue', label = 'PEGASOS')\n    plt.plot(count_list_A, test_error_A_int, color = 'red', label = 'AdaGrad')\n    plt.legend()\n    plt.show()\n    \n    return test_error_P, test_error_A\n\n# **********************************************************************************************\n#\n#   function calls\n#    \n# **********************************************************************************************\n    \n# load training data\nX_train, Y_train = loadTrainData('training.1600000.processed.noemoticon.csv')\n\n# load test data\nX_test, Y_test = loadTestData('testdata.manual.2009.06.14.csv')\n\n# generate feature matrices of training and test data\nX_train_sparse, X_test_sparse = createUnigramFeatureMatrixFromTweets(X_train, X_test)\n\n# get decision \nw_P_list, w_A_list, count_list_P, count_list_A = runPegasosAndAdaGrad(X_train_sparse, Y_train)\n\n# print test accuracy results\ntest_error_P, test_error_A = testAccuracies(X_test_sparse, Y_test, w_P_list, w_A_list, count_list_P, count_list_A)\n\nend_time = time.time() - start_time1\n\nprint \"\\n\\n\\n\\n Total time taken by program to run (in seconds) = \", end_time\nprint \"\\n\\n\"\n", "meta": {"hexsha": "e490e4d8d5cc13025ef89e3d51a541d5cd129a67", "size": 27636, "ext": "py", "lang": "Python", "max_stars_repo_path": "main.py", "max_stars_repo_name": "ApurbaSengupta/Twitter-Sentiment-Classification", "max_stars_repo_head_hexsha": "2b7141811c6d3b603c30384ee31255807a1312c0", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-03-13T17:17:45.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-13T17:17:45.000Z", "max_issues_repo_path": "main.py", "max_issues_repo_name": "ApurbaSengupta/Twitter-Sentiment-Classification", "max_issues_repo_head_hexsha": "2b7141811c6d3b603c30384ee31255807a1312c0", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "main.py", "max_forks_repo_name": "ApurbaSengupta/Twitter-Sentiment-Classification", "max_forks_repo_head_hexsha": "2b7141811c6d3b603c30384ee31255807a1312c0", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.1686046512, "max_line_length": 172, "alphanum_fraction": 0.6392386742, "include": true, "reason": "import numpy,from scipy", "num_tokens": 7281, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48047867804790706, "lm_q2_score": 0.1112412079807702, "lm_q1q2_score": 0.05344902855505275}}
{"text": "![Callysto.ca Banner](https://github.com/callysto/curriculum-notebooks/blob/master/callysto-notebook-banner-top.jpg?raw=true)\n\n<a href=\"https://hub.callysto.ca/jupyter/hub/user-redirect/git-pull?repo=https%3A%2F%2Fgithub.com%2Fcallysto%2Fcurriculum-notebooks&branch=master&subPath=Science/ThermalExpansion/thermal-expansion.ipynb&depth=1\" target=\"_parent\"><img src=\"https://raw.githubusercontent.com/callysto/curriculum-notebooks/master/open-in-callysto-button.svg?sanitize=true\" width=\"123\" height=\"24\" alt=\"Open in Callysto\"/></a>\n\n%%html\n\n<script>\n  function code_toggle() {\n    if (code_shown){\n      $('div.input').hide('500');\n      $('#toggleButton').val('Show Code')\n    } else {\n      $('div.input').show('500');\n      $('#toggleButton').val('Hide Code')\n    }\n    code_shown = !code_shown\n  }\n\n  $( document ).ready(function(){\n    code_shown=false;\n    $('div.input').hide()\n  });\n</script>\n<form action=\"javascript:code_toggle()\"><input type=\"submit\" id=\"toggleButton\" value=\"Show Code\"></form>\n\nfrom ipywidgets import Output, IntSlider, VBox, Layout\nfrom IPython.display import Javascript,clear_output, display, HTML\nimport ipywidgets as widgets\nimport random\nfrom plotly.offline import init_notebook_mode, iplot\nfrom ipywidgets import HBox\nimport plotly.graph_objs as go\nimport numpy as np\nimport random\n\ninit_notebook_mode(connected=True)\n\n#This function produces a multiple choice form with four options\ndef multiple_choice(option_1, option_2, option_3, option_4):\n    option_list = [option_1, option_2, option_3, option_4]\n    answer = option_list[0]\n    letters = [\"(A) \", \"(B) \", \"(C) \", \"(D) \"]\n\n    #Boldface letters at the beginning of each option\n    start_bold = \"\\033[1m\"; end_bold = \"\\033[0;0m\"\n\n    #Randomly shuffle the options\n    random.shuffle(option_list)\n    \n    #Prints the letters (A) to (D) in sequence with randomly chosen options\n    for i in range(4):\n        option_text = option_list.pop()\n        print(start_bold + letters[i] + end_bold + option_text)\n\n        #Stores the correct answer\n        if option_text == answer:\n            letter_answer = letters[i]\n\n    button1 = widgets.Button(description=\"(A)\"); button2 = widgets.Button(description=\"(B)\")\n    button3 = widgets.Button(description=\"(C)\"); button4 = widgets.Button(description=\"(D)\")\n    \n    button1.style.button_color = 'Whitesmoke'; button2.style.button_color = 'Whitesmoke'\n    button3.style.button_color = 'Whitesmoke'; button4.style.button_color = 'Whitesmoke'\n    \n    container = widgets.HBox(children=[button1,button2,button3,button4])\n    display(container)\n    print(\" \", end='\\r')\n\n    def on_button1_clicked(b):\n        if \"(A) \" == letter_answer:\n            print(\"Correct! 👏\", end='\\r')\n            button1.style.button_color = '#abffa8'; button2.style.button_color = 'Whitesmoke'\n            button3.style.button_color = 'Whitesmoke'; button4.style.button_color = 'Whitesmoke'\n        else:\n            print(\"Try again! \", end='\\r')\n            button1.style.button_color = '#ffbbb8'; button2.style.button_color = 'Whitesmoke'\n            button3.style.button_color = 'Whitesmoke'; button4.style.button_color = 'Whitesmoke'\n\n    def on_button2_clicked(b):\n        if \"(B) \" == letter_answer:\n            print(\"Correct! 👏\", end='\\r')\n            button1.style.button_color = 'Whitesmoke'; button2.style.button_color = '#abffa8'\n            button3.style.button_color = 'Whitesmoke'; button4.style.button_color = 'Whitesmoke'\n        else:\n            print(\"Try again! \", end='\\r')\n            button1.style.button_color = 'Whitesmoke'; button2.style.button_color = '#ffbbb8'\n            button3.style.button_color = 'Whitesmoke'; button4.style.button_color = 'Whitesmoke'\n\n    def on_button3_clicked(b):\n        if \"(C) \" == letter_answer:\n            print(\"Correct! 👏\", end='\\r')\n            button1.style.button_color = 'Whitesmoke'; button2.style.button_color = 'Whitesmoke'\n            button3.style.button_color = '#abffa8'; button4.style.button_color = 'Whitesmoke'\n        else:\n            print(\"Try again! \", end='\\r')\n            button1.style.button_color = 'Whitesmoke'; button2.style.button_color = 'Whitesmoke'\n            button3.style.button_color = '#ffbbb8'; button4.style.button_color = 'Whitesmoke'\n\n    def on_button4_clicked(b):\n        if \"(D) \" == letter_answer:\n            print(\"Correct! 👏\", end='\\r')\n            button1.style.button_color = 'Whitesmoke'; button2.style.button_color = 'Whitesmoke'\n            button3.style.button_color = 'Whitesmoke'; button4.style.button_color = '#abffa8'\n        else:\n            print(\"Try again! \", end='\\r')\n            button1.style.button_color = 'Whitesmoke'; button2.style.button_color = 'Whitesmoke'\n            button3.style.button_color = 'Whitesmoke'; button4.style.button_color = '#ffbbb8'\n\n    button1.on_click(on_button1_clicked); button2.on_click(on_button2_clicked)\n    button3.on_click(on_button3_clicked); button4.on_click(on_button4_clicked)\n\ndef run_all(ev):\n    display(Javascript('IPython.notebook.execute_cell()'))\n\n# Thermal Linear Expansion\n\n## Introduction\n\nThe goal of this notebook is to discuss the following:\n- Review **Kinetic Molecular Theory** and how it relates to thermal expansion.\n- Derive a **formula** to compute thermal expansion.\n- **Apply** this formula to real-world scenarios.\n\n## Kinetic Molecular Theory\n\n**Summary:**\n\n- Matter is made up of particles that are constantly moving.\n- The temperature of a substance is a measure of the average kinetic energy of the particles.\n- There are spaces between particles of matter. The average amount of empty space between molecules gets progressively larger as a sample of matter moves from solid to the liquid and gas phases.\n\n<img style=\"float: center;\" src=\"images/particles.svg\" width=\"400\">\n\nstart_bold = \"\\033[1m\"; end_bold = \"\\033[0;0m\"\nquestion = start_bold + \"Key Question: \" + end_bold + \\\n\"Most solids \" + start_bold + \"expand\" + end_bold + \" when heated. Based on the points above, \" + start_bold + \"why is this the case?\" + end_bold\nprint(question)\nprint(\"\")\noption_1 = \"When heat is added to a substance, the molecules vibrate faster causing the space between molecules to increase.\"\noption_2 = \"An increase in temperature causes the molecules to loosen up and move freely but slowly around.\"\noption_3 = \"As objects become hotter, they contract and the molecules increase their speed.\"\noption_4 = \"An increase in temperature causes the molecules to tighten up and move in a constricted manner.\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\n## Thermal Linear Expansion\n\n**Definition:** The increase in length of a solid in one direction (due to an increase in temperature) is called *thermal linear expansion*. \n\n**Goal:** Given any solid, we wish to **predict** how much the solid will expand with a change in temperature; i.e. how do we predict the *change in length* ($\\Delta L$) of a solid due to an increase in temperature?\n\n<img style=\"float: center;\" src=\"images/RodExpanding.svg\"  width=\"400\">\n\nstart_bold = \"\\033[1m\"; end_bold = \"\\033[0;0m\"\nquestion = start_bold + \"Key Question: \" + end_bold + \"What \" + start_bold + \"variable(s)\" + end_bold + \" would you need know to predict how much a substance will expand when heat is added?\"\nprint(question)\nprint(\"\")\noption_1 = \"Type of material, Initial length/size, Amount of heat added\"\noption_2 = \"Type of material, Amount of heat added\"\noption_3 = \"Pressure acting material, Amount of heat added\"\noption_4 = \"Roughness of the material, Type of material\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\n**Fact:** The change of length $(\\Delta L)$ of a solid depends on **three** factors:\n1. *Initial length* of the solid $(L)$\n2. *Temperature change* $(\\Delta T)$\n3. Type of material, distinguished by a constant value named the *coefficient of linear expansion* $(\\alpha)$\n\nSome values for the coefficient of linear expansion are shown in the table below:\n\n Materials                 | Coefficient of linear expansion, $\\alpha$ $\\:$ ($1/°\\rm{C}$)\n ---                       | ---\n Aluminum                  | 25 $\\times$ 10$^{-6}$\n Concrete, iron, steel     | 12 $\\times$ 10$^{-6}$\n Copper                    | 16 $\\times$ 10$^{-6}$\n Glass (soft), Platinum    | 9 $\\times$ 10$^{-6}$\n Glass (Pyrex)             | 3 $\\times$ 10$^{-6}$\n\nThe following formula relates these **four quantities variables** together: \n\n$$\\Delta L = \\alpha L \\Delta T$$\n\nWe will derive this formula later on in the notebook. Before that, let's get accustomed to using this formula in practical situations.\n\n### Example\n\nThe longest continuous bridge in Saskatchewan is a 380 m long steel bridge in North Battleford. The temperature in the area varies from -40.0 $^\\circ$C to 30.0 $^\\circ$C. What is the *change in length of the bridge*? Round to two significant figures.\n\nout1 = Output()\nStep1B = widgets.Button(description=\"STEP 1\", layout=Layout(width='20%', height='100%'))\ncount1 = 1\n\ninfo1 = widgets.HTMLMath(value=\"Identify the variables that we know and what we're looking for:\")\nmath_text1 = widgets.HTMLMath(value=\"Initial length: $L=380\\:m$\")\nmath_text2 = widgets.HTMLMath(value=\"Change in temperature: $\\Delta T = T_{final} - T_{initial}$ = 30°C $-$ ($-$40°C) = 70°C\")\nmath_text3 = widgets.HTMLMath(value=\"Coefficient of linear expansion (specific to steel): \" + chr(0x3B1) + \" = $12 × 10^{-6}$ °C$^{-1}$ (reference from table)\")\nmath_text4 = widgets.HTMLMath(value=\"Change in length of the bridge:  $\\Delta L$ = ?\")\n\n\n\ndef on_Step1B_clicked(b):\n    global count1\n    count1 += 1\n    with out1:\n        clear_output()\n        if count1 % 2 == 0:\n            display(info1, math_text1, math_text2, math_text3, math_text4)\n            \ndisplay(VBox([Step1B, out1]))\nStep1B.on_click(on_Step1B_clicked)\n\nout2 = Output()\nStep2B = widgets.Button(description=\"STEP 2\", layout=Layout(width='20%', height='100%'))\ncount2 = 1\n\ninfo2 = widgets.HTMLMath(value=\"Substitute each known value into the formula and solve for the missing variable:\")\nmath_text5 = widgets.HTMLMath(value=\"$\\Delta L$ = \" + chr(0x3B1) + \" L $\\Delta T$ = ($12 × 10^{-6}$ °C$^{-1}$)(380 m)(70 °C) = 0.3192 m\")\n\ndef on_Step2B_clicked(b):\n    global count2\n    count2 += 1\n    with out2:\n        clear_output()\n        if count2 % 2 == 0:\n            display(info2, math_text5)\n            \ndisplay(VBox([Step2B, out2]))\nStep2B.on_click(on_Step2B_clicked)\n\nout3 = Output()\nStep3B = widgets.Button(description=\"STEP 3\", layout=Layout(width='20%', height='100%'))\ncount3 = 1\n\ninfo3 = widgets.HTMLMath(value=\"Round to the correct number of significant figures and convert to the correct units (if needed):\")\nmath_text6 = widgets.HTMLMath(value=\"0.3192 m = 0.32 m or 32 cm\")\n\ndef on_Step3B_clicked(b):\n    global count3\n    count3 += 1\n    with out3:\n        clear_output()\n        if count3 % 2 == 0:\n            display(info3, math_text6)\n            \ndisplay(VBox([Step3B, out3]))\nStep3B.on_click(on_Step3B_clicked)\n\n### Practice\nTry multiple practice problems by clicking the 'Generate New Question' button upon completing a problem.\n\nbutton = widgets.Button(description=\"Generate New Question\", layout=Layout(width='20%', height='100%'))\nbutton.on_click(run_all)\ndisplay(button)\n\n#Variables to randomize\ninitial_length = round(random.uniform(2.0, 6.0), 2)\ninitial_temp = round(random.uniform(-50.0, -20.0), 1)\nfinal_temp = round(random.uniform(30.0, 45.0), 1)\n\n#Dictionary of different materials\nmaterials = {\"aluminum\": 0.000025, \"iron\": 0.000012, \"steel\": 0.000012, \"glass (soft)\": 0.000009, \"glass (pyrex)\": 0.000003, \"concrete\": 0.000012, \"platinum\": 0.000009, \"copper\": 0.000016}\nchosen_material = random.choice(list(materials.keys()))\n\n#Print question\nquestion = \"A piece of {} is {} m on a cold winter day ({} °C). How much longer is it on a very hot summer day ({} °C)? Round to two decimal places.\".format(chosen_material, initial_length, initial_temp, final_temp)\nprint(question)\n\n#Answer calculation\nanswer = round((initial_length * materials[chosen_material] * (final_temp - initial_temp))*100, 2)\n\n#Define range of values for random multiple choices\nmini = 1\nmaxa = 100\n\n#Create three choices that are unique (and not equal to the answer)\nchoice_list = random.sample(range(mini,maxa),3)\nwhile choice_list.count(int(answer*100)) >= 1:\n    choice_list = random.sample(range(mini,maxa),3)\n    \n#Assign each multiple choice to these four variables\n#Option_1 contains the answer\noption_1 = '{:.2f}'.format(answer) + \" cm\" \noption_2 = '{:.2f}'.format(choice_list[0]/100) + \" cm\"\noption_3 = '{:.2f}'.format(choice_list[1]/100) + \" cm\"\noption_4 = '{:.2f}'.format(choice_list[2]/100) + \" cm\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\n## Deriving the Formula\n\nNow that you are comfortable using the thermal expansion formula, we now discuss how it is derived experimentally. Of the four quantities in the equation, $\\Delta L = \\alpha L \\Delta T$, it is the coefficient of linear expansion ($\\alpha$) that may be still be mysterious in how it is measured. Previously, we have referenced a table of values to determine $\\alpha$, but *where do these values come from?*\n\nWe demonstrate how to calculate $\\alpha$ experimentally below. We will require two different materials so we can compare each expansion (which you can select in the dropdown menus below). We then apply *the exact same amount of heat to both materials* (which you can adjust using the slider). When you are ready, click the \"Calculate Linear Expansion\" button below. \n\ncoefficients = {\"Aluminum\": 0.000025, \"Iron\": 0.000012, \"Steel\": 0.000012, \"Glass (soft)\": 0.000009, \"Glass (Pyrex)\": 0.000003, \"Concrete\": 0.000012, \"Platinum\": 0.000009, \"Copper\": 0.000016}\n\ngraph_out = Output()\n\nselection1 = widgets.Dropdown(\n    options={'Aluminum', 'Steel', 'Copper'},\n    value='Aluminum',\n    description='Material 1:',\n)\n\nselection2 = widgets.Dropdown(\n    options={'Iron', 'Platinum', 'Glass (Pyrex)'},\n    value='Iron',\n    description='Material 2:',\n)\n\ntemp_slider = IntSlider(continuous_update=False, wait=True, value=500, min=50, max=1000, step=50, description=chr(0x0394) + 'T (°C)')\ninitial_length_slider = IntSlider(continuous_update=False, wait=True, value=5, min=1, max=10, step=1, description='L (m)')\n\nsubmit_button = widgets.Button(description=\"Calculate Linear Expansion\", layout=Layout(width='20%', height='88%'),button_style='success')\n\n################ Functions ##################\n\ndef initial_graph(material1, material2):\n################# Parametric Equations #################\n    s3 = np.linspace(0, 2 * np.pi, 30)\n    t3 = np.linspace(0, 5, 30)\n    tGrid3, sGrid3 = np.meshgrid(s3, t3)\n\n    x3 = np.cos(tGrid3) + 1.5\n    y3 = np.sin(tGrid3) + 1.5\n    z3 = sGrid3\n\n    s4 = np.linspace(0, 2 * np.pi, 30)\n    t4 = np.linspace(0, 5, 30)\n    tGrid4, sGrid4 = np.meshgrid(s4, t4)\n\n    x4 = np.cos(tGrid4) + 3.5\n    y4 = np.sin(tGrid4) + 3.5\n    z4 = sGrid4\n\n    ######################################################\n\n    trace1 = go.Surface(x=x3, y=y3, z=z3, colorscale='Greens', showscale=False, text = material1, hoverinfo='text')\n    trace2 = go.Surface(x=x4, y=y4, z=z4, colorscale='Blues', showscale=False, text = material2, hoverinfo='text')\n    data = [trace1, trace2]\n    layout = go.Layout(title = material1 + \" and \" + material2 + \" (before heat is applied)\",\n    scene = dict(xaxis = dict(title='', range = [0,5],\n                     backgroundcolor=\"rgb(200, 200, 230)\",\n                     gridcolor=\"rgb(255, 255, 255)\",\n                     showbackground=True,\n                     zerolinecolor=\"rgb(255, 255, 255)\",\n                     showticklabels=False,),\n                yaxis = dict(title='', range = [0,5],\n                    backgroundcolor=\"rgb(230, 200,230)\",\n                    gridcolor=\"rgb(255, 255, 255)\",\n                    showbackground=True,\n                    zerolinecolor=\"rgb(255, 255, 255)\",\n                    showticklabels=False),\n                zaxis = dict(title='', range = [0,4],\n                    backgroundcolor=\"rgb(230, 230,200)\",\n                    gridcolor=\"rgb(255, 255, 255)\",\n                    showbackground=True,\n                    zerolinecolor=\"rgb(255, 255, 255)\",\n                    showticklabels=False,),),\n              )\n    config={'showLink': False, 'editable': False}\n    fig = go.Figure(data=data, layout=layout)\n    iplot(fig, config=config)\n\n\ndef graph(h, h2, material1, material2, initial_length):\n    with graph_out:\n        clear_output(wait=True)\n        \n        ################# Parametric Equations #################\n        s = np.linspace(0, 2 * np.pi, 30)\n        t = np.linspace(0, h, 30)\n        tGrid, sGrid = np.meshgrid(s, t)\n        \n        x = np.cos(tGrid) + 1.5\n        y = np.sin(tGrid) + 1.5\n        z = sGrid + initial_length\n        \n        s2 = np.linspace(0, 2 * np.pi, 30)\n        t2 = np.linspace(0, h2, 30)\n        tGrid2, sGrid2 = np.meshgrid(s2, t2)\n        \n        x2 = np.cos(tGrid2) + 3.5\n        y2 = np.sin(tGrid2) + 3.5\n        z2 = sGrid2 + initial_length\n        \n        s3 = np.linspace(0, 2 * np.pi, 30)\n        t3 = np.linspace(0, initial_length, 30)\n        tGrid3, sGrid3 = np.meshgrid(s3, t3)\n        \n        x3 = np.cos(tGrid3) + 1.5\n        y3 = np.sin(tGrid3) + 1.5\n        z3 = sGrid3\n        \n        s4 = np.linspace(0, 2 * np.pi, 30)\n        t4 = np.linspace(0, initial_length, 30)\n        tGrid4, sGrid4 = np.meshgrid(s4, t4)\n        \n        x4 = np.cos(tGrid4) + 3.5\n        y4 = np.sin(tGrid4) + 3.5\n        z4 = sGrid4\n        ######################################################\n        \n        trace1 = go.Surface(x=x, y=y, z=z, colorscale='Reds', showscale=False, text = chr(0x0394) + 'L (' + material1 + ') = ' + str(round(h/5 * 100 ,5)) + ' cm', hoverinfo='text')\n        trace2 = go.Surface(x=x2, y=y2, z=z2, colorscale='Reds', showscale=False, text = chr(0x0394) + 'L (' + material2 + ') = ' + str(round(h2/5 * 100,5)) + ' cm', hoverinfo='text')\n        trace3 = go.Surface(x=x3, y=y3, z=z3, colorscale='Greens', showscale=False, text = material1, hoverinfo='text')\n        trace4 = go.Surface(x=x4, y=y4, z=z4, colorscale='Blues', showscale=False, text = material2, hoverinfo='text')\n        \n        data = [trace1, trace2, trace3, trace4]\n        layout = go.Layout(title = chr(0x0394) + 'L (' + material1 + ') = ' + str(round(h/5 * 100 ,5)) + ' cm;  ' + chr(0x0394) + 'L (' + material2 + ') = ' + str(round(h2/5 * 100,5)) + ' cm',\n                    scene = dict(\n                    xaxis = dict(title='', range = [0,5],\n                         backgroundcolor=\"rgb(200, 200, 230)\",\n                         gridcolor=\"rgb(255, 255, 255)\",\n                         showbackground=True,\n                         zerolinecolor=\"rgb(255, 255, 255)\",\n                         showticklabels=False,),\n                    yaxis = dict(title='', range = [0,5],\n                        backgroundcolor=\"rgb(230, 200,230)\",\n                        gridcolor=\"rgb(255, 255, 255)\",\n                        showbackground=True,\n                        zerolinecolor=\"rgb(255, 255, 255)\",\n                        showticklabels=False),\n                    zaxis = dict(title='', range = [0,initial_length + max(h,h2)],\n                        backgroundcolor=\"rgb(230, 230,200)\",\n                        gridcolor=\"rgb(255, 255, 255)\",\n                        showbackground=True,\n                        zerolinecolor=\"rgb(255, 255, 255)\",\n                        showticklabels=False,),),\n                  )\n        config={'showLink': False, 'editable': False}\n        fig = go.Figure(data=data, layout=layout)\n        note = widgets.HTMLMath(value=r\"$\\textbf{Note: } \\text{The thermal expansion shown below (coloured red) is magnified (5x) for easier viewing.}$\")\n        display(note)\n        iplot(fig, config=config)\n\ndef on_submit_button_clicked(b):\n    height = (initial_length_slider.value*temp_slider.value*coefficients[selection1.value]) * 5\n    height2 = (initial_length_slider.value*temp_slider.value*coefficients[selection2.value]) *  5\n    graph(height, height2, selection1.value, selection2.value, initial_length_slider.value)\n    \n\ndisplay(HBox([VBox([selection1, selection2]), VBox([temp_slider, initial_length_slider])]))\ndisplay(submit_button)\ndisplay(graph_out)\n\nwith graph_out:\n    initial_graph(selection1.value, selection2.value)\n    \nsubmit_button.on_click(on_submit_button_clicked)\n\n*Use the interactive simulation above to answer the following two questions.*\n\nstart_bold = \"\\033[1m\"; end_bold = \"\\033[0;0m\"\nquestion = \"Keep ΔT fixed and only adjust L. Run the simulation many times, each with a different value for L (but the same value for ΔT). What happens to ΔL?\"\nprint(question)\nprint(\"\")\noption_1 = \"ΔL increases as L increases and ΔL decreases as L decreases.\"\noption_2 = \"ΔL increases as L decreases and ΔL decreases as L increases.\"\noption_3 = \"There is no relationship between ΔL and L.\"\noption_4 = \"When L decreases or increases, ΔL remains constant.\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\nstart_bold = \"\\033[1m\"; end_bold = \"\\033[0;0m\"\nquestion = \"Now, keep L fixed and only adjust ΔT. Again, run the simulation many times, each with a different value for ΔT (but the same value for L). What happens to ΔL?\"\nprint(question)\nprint(\"\")\noption_1 = \"ΔL increases as ΔT increases and ΔL decreases as ΔT decreases.\"\noption_2 = \"ΔL increases as ΔT decreases and ΔL decreases as ΔT increases.\"\noption_3 = \"There is no relationship between ΔL and ΔT.\"\noption_4 = \"When ΔT decreases or increases, ΔL remains constant.\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\n**Goal:** To establish a thermal expansion formula capable of accurately predicting how much a material will expand linearly when heat is applied.\n\nObserve how $\\Delta L$ is different for some materials (aluminum versus platinum), but the same for others (steel versus iron). This is due to similarities and differences between the chemical composition of each material. For example, steel is comprised of around 90-95% iron, which accounts for both materials' identical rate of thermal expansion. \n\nSimply knowing the initial length ($L$) and change in temperature ($\\Delta T$) is clearly not enough to predict change in length ($\\Delta L$). We can see this above: when both materials share the same values of $L$ and $\\Delta T$, their $\\Delta L$ is often different. We somehow must assign a *constant* value (which we call $\\alpha$) for each material that we can use alongside $L$ and $\\Delta T$ to compute $\\Delta L$. Since we experimentally measured $\\Delta L$ above, we in fact have all the information we need to establish such a constant.\n\nThe above simulation and questions indicates that the relationship between $L$, $\\Delta T$, and $\\Delta L$ is direct rather than inverse ($1/\\Delta T$ or $1/L$). Since $\\Delta L$ becomes larger as both $L$ and $\\Delta T$ become larger, we guess that their relationship is multiplicative. Hence, we begin by writing down the following formula that we want:\n\n$$\\Delta L = \\alpha L \\Delta T$$\n\nThe $\\alpha$ is the constant that we need, but do not know. However, we measured $\\Delta L$ and we know both $L$ and $\\Delta T$, so computing $\\alpha$ is easy:\n\n$$\\alpha  = \\dfrac{\\Delta L}{L \\Delta T}$$\n    \nUsing the sliders below, input the change in length ($\\Delta L$) for both materials 1 and 2 from the above experimental simulation to compute $\\alpha$ for each material. **Hint:** Use your *arrow keys* on your keyboard to use the sliders with precision.\n\nout_text = Output()\n\n################ Widgets #################\nstyle = {'description_width': 'initial'}\ntemp1_slider = IntSlider(continuous_update=False, wait=True, value=500, min=10, max=1000, step=1, description=chr(0x0394) + 'T (°C)')\nchange1_slider = widgets.FloatSlider(continuous_update=False, wait=True, value=0, min=0, max=10, step=0.001, readout_format='.3f', description=chr(0x0394) + 'L'+ chr(0x2081) + ' (cm)', style=style)\nchange2_slider = widgets.FloatSlider(continuous_update=False, wait=True, value=0, min=0, max=10, step=0.001, readout_format='.3f', description=chr(0x0394) + 'L'+ chr(0x2082) + ' (cm)', style=style)\ncoeff_calc = widgets.Button(description=\"Calculate \" + chr(0x03b1) + chr(0x2081) + \" and \" + chr(0x03b1) + chr(0x2082), layout=Layout(width='20%', height='88%'),button_style='success')\n###########################################\n\ndisplay(VBox([temp1_slider, change1_slider, change2_slider, coeff_calc]))\n\ndef on_submit_button_clicked(b):\n    ans1 = round(change1_slider.value / (300.0 * temp1_slider.value), 8)\n    ans2 = round(change2_slider.value / (300.0 * temp1_slider.value), 8)\n    with out_text:\n        clear_output()\n        text_answer = widgets.HTMLMath(value=r\"$\\alpha_1 = $ \" + str(ans1) + \" °C$^{-1}$\" + \"$\\qquad$\" + r\"$\\alpha_2 = $ \" + str(ans2) + \" °C$^{-1}$\")\n        text_answer2 = widgets.HTMLMath(value=r\"Compare each $\\alpha_1$ and $\\alpha_2$ to those found in the table of coefficients of linear expansion above. See if they match.\")\n        display(text_answer)\n        display(text_answer2)\n\n### Widget Interaction Function Calls ###\ncoeff_calc.on_click(on_submit_button_clicked)\n\ndisplay(out_text)\n\n## Variations on the Thermal Expansion Formula\n\nAs we've just seen, the formula $\\Delta L = \\alpha L \\Delta T$ is not always used to find $\\Delta L$. Often, we can experimentally measure $\\Delta L$. Depending on the application, we can then theoretically compute one of the other quantities (assuming we know the value of two of the other quantities). It is worth noting the three variations of the thermal expansion formula:\n\n$$\\alpha = \\dfrac{\\Delta L}{L \\Delta T} \\qquad L = \\dfrac{\\Delta L}{\\alpha \\Delta T} \\qquad \\Delta T = \\dfrac{\\Delta L}{\\alpha L}$$\n\n**Note:** This is **one** formula being displayed in **three** different ways. It is convenient to make use of the variation that corresponds to the unknown value that you wish to determine.\n\n### Practice \n\nTry the three different types of questions using the above variations of the thermal expansion formula. Use the 'Generate New Question' button to complete additional practice problems.\n\nbutton1 = widgets.Button(description=\"Generate New Question\", layout=Layout(width='20%', height='100%'))\nbutton1.on_click(run_all)\ndisplay(button1)\n\n#Variables to randomize\nchange_length = round(random.uniform(0.2, 0.9), 2)\ninitial_length = round(random.uniform(1.0, 3.0), 2)\ninitial_temp = round(random.uniform(10.0, 25.0), 1)\nfinal_temp = round(random.uniform(100.0, 150.0), 1)\n\n#Print question\nquestion = \"An newly made synthetic material {} m long expands {} mm when heated from {}°C to {}°C. What is the coefficient of linear expansion of this new material?\".format(initial_length, change_length, initial_temp, final_temp)\nprint(question)\n\n#Answer calculation\nanswer = round((change_length/1000) / (initial_length * (final_temp - initial_temp)), 8)\n\n#Define range of values for random multiple choices\nmini = 100\nmaxa = 900\n\n#Create three choices that are unique (and not equal to the answer)\nchoice_list = random.sample(range(mini,maxa),3)\nwhile choice_list.count(int(answer*100000000)) >= 1:\n    choice_list = random.sample(range(mini,maxa),3)\n    \n#Assign each multiple choice to these four variables\n#Option_1 contains the answer\noption_1 = str(answer) + \" °C\" + chr(0x207B) + chr(0x00B9) \noption_2 = str(choice_list[0]/100000000) + \" °C\" + chr(0x207B) + chr(0x00B9)\noption_3 = str(choice_list[1]/100000000) + \" °C\" + chr(0x207B) + chr(0x00B9)\noption_4 = str(choice_list[2]/100000000) + \" °C\" + chr(0x207B) + chr(0x00B9)\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\nbutton2 = widgets.Button(description=\"Generate New Question\", layout=Layout(width='20%', height='100%'))\nbutton2.on_click(run_all)\ndisplay(button2)\n\n#Variables to randomize\nchange_length = round(random.uniform(0.5, 2.0), 2)\ninitial_temp = round(random.uniform(20.0, 30.0), 1)\nfinal_temp = round(random.uniform(100.0, 250.0), 1)\n\n#Dictionary of different materials\nmaterials = {\"aluminum\": 0.000025, \"iron\": 0.000012, \"steel\": 0.000012, \"glass (soft)\": 0.000009, \"glass (pyrex)\": 0.000003, \"concrete\": 0.000012, \"platinum\": 0.000009, \"copper\": 0.000016}\nchosen_material = random.choice(list(materials.keys()))\n\n#Print question\nquestion = \"A piece of {} changes in length by {} m. The initial temperature was {}°C and the final temperature was {}°C. Determine the original length of the material. Leave your answer unrounded.\".format(chosen_material, change_length, initial_temp, final_temp)\nprint(question)\n\n#Answer calculation\nanswer = round(change_length / (materials[chosen_material] * (final_temp - initial_temp)), 2)\n\n#Define range of values for random multiple choices\nmini = 500\nmaxa = 1500\n\n#Create three choices that are unique (and not equal to the answer)\nchoice_list = random.sample(range(mini,maxa),3)\nwhile choice_list.count(int(answer)) >= 1:\n    choice_list = random.sample(range(mini,maxa),3)\n    \n#Assign each multiple choice to these four variables\n#Option_1 contains the answer\noption_1 = '{:.2f}'.format(answer) + \" m\" \noption_2 = '{:.2f}'.format(choice_list[0]) + \" m\"\noption_3 = '{:.2f}'.format(choice_list[1]) + \" m\"\noption_4 = '{:.2f}'.format(choice_list[2]) + \" m\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\nbutton3 = widgets.Button(description=\"Generate New Question\", layout=Layout(width='20%', height='100%'))\nbutton3.on_click(run_all)\ndisplay(button3)\n\n\n#Variables to randomize\nchange_length = round(random.uniform(1.0, 4.0), 2)\ninitial_length = round(random.uniform(100.0, 150.0), 1)\n\n#Dictionary of different materials\nmaterials = {\"aluminum\": 0.000025, \"iron\": 0.000012, \"steel\": 0.000012, \"glass (soft)\": 0.000009, \"glass (pyrex)\": 0.000003, \"concrete\": 0.000012, \"platinum\": 0.000009, \"copper\": 0.000016}\nchosen_material = random.choice(list(materials.keys()))\n\n#Print question\nquestion = \"By how much would you need to heat a {} inch {} sample to make it expand by {} inches? Round to the nearest degree Celsius.\".format(initial_length, chosen_material, change_length)\nprint(question)\n\n#Answer calculation\nanswer = int(change_length / (materials[chosen_material] * initial_length))\n\n#Define range of values for random multiple choices\nmini = 600\nmaxa = 3000\n\n#Create three choices that are unique (and not equal to the answer)\nchoice_list = random.sample(range(mini,maxa),3)\nwhile choice_list.count(answer) >= 1:\n    choice_list = random.sample(range(mini,maxa),3)\n    \n#Assign each multiple choice to these four variables\n#Option_1 contains the answer\noption_1 = str(answer) + \" °C\" \noption_2 = str(choice_list[0]) + \" °C\"\noption_3 = str(choice_list[1]) + \" °C\"\noption_4 = str(choice_list[2]) + \" °C\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\n## Application: Aircraft Components\n\nAircraft materials often require *specialized properties* in order to operate in the most desirable manner. The specialized property of the material may be the most important consideration in materials selection. Listed below are several key specialized properties considered in aircraft materials selection:\n\n- Electrical conductivity (important for the outer skin of the aircraft)\n- Stealth (materials that can absorb radar waves and/or reduce the infrared visibility are used in the external surface of covert military aircraft)\n- Thermal conductivity (used in high-temperature applications, such as heat shields and engine components)\n- <span style=\"color: maroon\">Thermal expansion (used in high-temperature range applications, such as wing and engine components)</span>\n\n### Problem\n\nAn unknown metal alloy is being tested to discover its thermal properties to see if it suitable for use as a *spar*, which is a component of an airplane wing (shown in red below). The alloy is formed into a bar measuring 1.00 metre in length and it is then heated from its starting temperature of 30 °C to a final temperature of 100.0 °C. The length of the heated bar is measured to be exactly 1.002 metres in length. **What is the coefficient of thermal expansion of the alloy? Round your answer to two significant figures.**\n\n<img style=\"float: center;\" src=\"images/WingSpar.svg\" width=\"600\">\n\noption_1 = str(0.000029) + \" °C\" + chr(0x207B) + chr(0x00B9)\noption_2 = str(0.014) + \" °C\" + chr(0x207B) + chr(0x00B9)\noption_3 = str(0.000032) + \" °C\" + chr(0x207B) + chr(0x00B9)\noption_4 = str(0.0140) + \" °C\" + chr(0x207B) + chr(0x00B9)\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\nThe aircraft wing (from above) experiences temperature extremes that span 210 ℃. The spar for the wing will have a length of 18.0 metres. Testing indicates that the aircraft wing will remain stable only if the spar never expands to a length larger than 18.103 metres. **If the component is made from the metal alloy in question, will it meet this requirement?**\n\n**Hint:** Use the sliders below to calculate the linear expansion of the spar.\n\n################ Widgets #################\napp_out = Output()\nstyle = {'description_width': 'initial'}\ntemp_span = IntSlider(continuous_update=False, wait=True, value=0, min=0, max=500, step=1, description=chr(0x0394) + 'T (°C)')\ninitialL_alloy = widgets.FloatSlider(continuous_update=False, wait=True, value=0, min=0, max=30, step=1, readout_format='.1f', description= 'L (m)', style=style)\nlinear_constant = widgets.FloatSlider(continuous_update=False, wait=True, value=0, min=0, max=10, step=0.1, readout_format='.1f', description= chr(0x03b1) + \" (1\" + chr(0x2A09) + \"10\" + chr(0x207B) + chr(0x2075) + \" , \" + chr(0x2103) + chr(0x207B) + chr(0x00B9) + \")\", style=style)\ncalc_change = widgets.Button(description=\"Calculate Linear Expansion\", layout=Layout(width='20%', height='88%'),button_style='success')\n\n############## Functions ################\ndef initial_spar():\n    layout = go.Layout(title = \"Unknown Alloy (before heat is applied)\", scene = dict(\n                    xaxis = dict(title='', range = [0,5],\n                         backgroundcolor=\"rgb(200, 200, 230)\",\n                         gridcolor=\"rgb(255, 255, 255)\",\n                         showbackground=True,\n                         zerolinecolor=\"rgb(255, 255, 255)\",\n                         showticklabels=False,),\n                    yaxis = dict(title='', range = [0,5],\n                        backgroundcolor=\"rgb(230, 200,230)\",\n                        gridcolor=\"rgb(255, 255, 255)\",\n                        showbackground=True,\n                        zerolinecolor=\"rgb(255, 255, 255)\",\n                        showticklabels=False),\n                    zaxis = dict(title='', range = [0,18],\n                        backgroundcolor=\"rgb(230, 230,200)\",\n                        gridcolor=\"rgb(255, 255, 255)\",\n                        showbackground=True,\n                        zerolinecolor=\"rgb(255, 255, 255)\",\n                        showticklabels=False,),),\n                  )\n    data = [go.Mesh3d(\n            x = [2, 2, 4, 4, 2, 2, 4, 4],\n            y = [2, 3, 3, 2, 2, 3, 3, 2],\n            z = [0, 0, 0, 0, 18, 18, 18, 18],\n            i = [7, 0, 0, 0, 4, 4, 6, 6, 4, 0, 3, 2],\n            j = [3, 4, 1, 2, 5, 6, 5, 2, 0, 1, 6, 3],\n            k = [0, 7, 2, 3, 6, 7, 1, 1, 5, 5, 7, 6],\n            name='Unknown Alloy',\n            color='#000066',\n            text = \"Spar (wing component; unknown alloy)\", hoverinfo='text',\n        )]\n    config={'showLink': False, 'editable': False}\n    fig = go.Figure(data=data, layout=layout)\n    iplot(fig, config=config)\n\n\ndef draw_spar(new, i_height):\n    clear_output(wait=True)\n    layout = go.Layout(title = chr(0x0394) + 'L (Unknown Alloy) = ' + str(round(new * 100 ,5)) + ' cm', scene = dict(\n                    xaxis = dict(title='', range = [0,5],\n                         backgroundcolor=\"rgb(200, 200, 230)\",\n                         gridcolor=\"rgb(255, 255, 255)\",\n                         showbackground=True,\n                         zerolinecolor=\"rgb(255, 255, 255)\",\n                         showticklabels=False,),\n                    yaxis = dict(title='', range = [0,5],\n                        backgroundcolor=\"rgb(230, 200,230)\",\n                        gridcolor=\"rgb(255, 255, 255)\",\n                        showbackground=True,\n                        zerolinecolor=\"rgb(255, 255, 255)\",\n                        showticklabels=False),\n                    zaxis = dict(title='', range = [0,18],\n                        backgroundcolor=\"rgb(230, 230,200)\",\n                        gridcolor=\"rgb(255, 255, 255)\",\n                        showbackground=True,\n                        zerolinecolor=\"rgb(255, 255, 255)\",\n                        showticklabels=False,),),\n                  )\n    data = [go.Mesh3d(\n            x = [2, 2, 4, 4, 2, 2, 4, 4],\n            y = [2, 3, 3, 2, 2, 3, 3, 2],\n            z = [0, 0, 0, 0, 18, 18, 18, 18],\n            i = [7, 0, 0, 0, 4, 4, 6, 6, 4, 0, 3, 2],\n            j = [3, 4, 1, 2, 5, 6, 5, 2, 0, 1, 6, 3],\n            k = [0, 7, 2, 3, 6, 7, 1, 1, 5, 5, 7, 6],\n            name='Unknown Alloy',\n            color='#000066',\n            text = \"Initial length (L) = \" + str(i_height) + ' m', hoverinfo='text',\n        ), go.Mesh3d(\n            x = [2, 2, 4, 4, 2, 2, 4, 4],\n            y = [2, 3, 3, 2, 2, 3, 3, 2],\n            z = [18, 18, 18, 18, 18+new, 18+new, 18+new, 18+new],\n            i = [7, 0, 0, 0, 4, 4, 6, 6, 4, 0, 3, 2],\n            j = [3, 4, 1, 2, 5, 6, 5, 2, 0, 1, 6, 3],\n            k = [0, 7, 2, 3, 6, 7, 1, 1, 5, 5, 7, 6],\n            name='Thermal Expansion',\n            color = \"#CC0000\",\n            text = \"Thermal Expansion (\"+chr(0x0394)+\"L) = \" + str(round(new,5)) + ' m', hoverinfo='text',\n        )]\n    config={'showLink': False, 'editable': False}\n    fig = go.Figure(data=data, layout=layout)\n    iplot(fig, config=config)\n\n\ndef on_submit_button_clicked(b):\n    alloy_change = temp_span.value * initialL_alloy.value * (linear_constant.value * 0.00001)\n    with app_out:\n        draw_spar(alloy_change, initialL_alloy.value)\n\n\n######### Display #########\ndisplay(VBox([temp_span, initialL_alloy, linear_constant]))\ndisplay(calc_change)\ndisplay(app_out)\n\nwith app_out:\n    initial_spar()\n    \ncalc_change.on_click(on_submit_button_clicked)\n\noption_1 = \"The final length of the spar is 18.10962 m; therefore, it fails the requirement.\"\noption_2 = \"The final length of the spar is 10.962 cm; therefore, it passes the requirement.\"\noption_3 = \"The final length of the spar is 18.103 m; therefore, it passes the requirement.\"\noption_4 = \"The final length of the spar is 28.962 m; therefore, it fails the requirement.\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\n## Conclusion\n\n- Thermal Linear Expansion is calculated using the formula: $\\Delta L = \\alpha L \\Delta T$.\n- The coefficient of linear expansion ($\\alpha$) is experimentally calculated. The experiment involves measuring $\\Delta L$ and solving for $\\alpha$ using the above formula.\n- If the material is known (such as steel, concrete, iron, etc.) you can reference the material's coefficient of linear expansion using a Table of Coefficient of Linear Expansion.\n- There are many applications to being able to predict thermal expansion, such as the building of bridges, skyscrapers, airplanes, cars, and piping (to name a few).\n- This notebook covered *linear* thermal expansion. If you are interested in applying what you have learned or gaining further knowledge of material science, you're next step is to study *area expansion* and *volume expansion*, which will explore the 2-dimensional and 3-dimensional expansion of materials.\n\n[![Callysto.ca License](https://github.com/callysto/curriculum-notebooks/blob/master/callysto-notebook-banner-bottom.jpg?raw=true)](https://github.com/callysto/curriculum-notebooks/blob/master/LICENSE.md)", "meta": {"hexsha": "3557e1c99806fe9bb76a02037389e7280e854135", "size": 39726, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/curriculum-notebooks/Science/ThermalExpansion/thermal-expansion.py", "max_stars_repo_name": "BryceHaley/curriculum-jbook", "max_stars_repo_head_hexsha": "d1246799ddfe62b0cf5c389394a18c2904383437", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-18T18:19:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T18:19:40.000Z", "max_issues_repo_path": "_build/jupyter_execute/curriculum-notebooks/Science/ThermalExpansion/thermal-expansion.py", "max_issues_repo_name": "callysto/curriculum-jbook", "max_issues_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/curriculum-notebooks/Science/ThermalExpansion/thermal-expansion.py", "max_forks_repo_name": "callysto/curriculum-jbook", "max_forks_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 50.0327455919, "max_line_length": 545, "alphanum_fraction": 0.6530735538, "include": true, "reason": "import numpy", "num_tokens": 10887, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.2782567937024021, "lm_q2_score": 0.19193278413614728, "lm_q1q2_score": 0.05340660112009961}}
{"text": "# -*- coding: utf-8 -*-\n# ---\n# jupyter:\n#   jupytext:\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.5'\n#       jupytext_version: 1.11.3\n#   kernelspec:\n#     display_name: 'Python 3.6.7 64-bit (''base'': conda)'\n#     name: python367jvsc74a57bd050da0f6fa72fb86d21724871d314354b884db45bd357078f1680189ca335f685\n# ---\n\n# + [markdown] id=\"view-in-github\" colab_type=\"text\"\n# <a href=\"https://colab.research.google.com/github/probml/pyprobml/blob/master/notebooks/text_preproc_torch.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n\n# + [markdown] id=\"Yn51eYujm5S1\"\n# # Text preprocessing\n#\n# We discuss how to convert a sequence of words or characters into numeric form, which can then be fed into an ML model.\n#\n#\n#\n\n# + id=\"ysx0t0REm4r0\"\nimport numpy as np\nimport matplotlib.pyplot as plt\nnp.random.seed(seed=1)\nimport math\n\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\nfrom torch.utils import data\n\n# !mkdir figures # for saving plots\n\n\n# + id=\"V6Jbluorndzr\"\nimport collections\nimport re\nimport random\nimport os\nimport requests\nimport zipfile\nimport hashlib\n\n\n# +\n# Required functions for downloading data\n\ndef download(name, cache_dir=os.path.join('..', 'data')):\n    \"\"\"Download a file inserted into DATA_HUB, return the local filename.\"\"\"\n    assert name in DATA_HUB, f\"{name} does not exist in {DATA_HUB}.\"\n    url, sha1_hash = DATA_HUB[name]\n    os.makedirs(cache_dir, exist_ok=True)\n    fname = os.path.join(cache_dir, url.split('/')[-1])\n    if os.path.exists(fname):\n        sha1 = hashlib.sha1()\n        with open(fname, 'rb') as f:\n            while True:\n                data = f.read(1048576)\n                if not data:\n                    break\n                sha1.update(data)\n        if sha1.hexdigest() == sha1_hash:\n            return fname  # Hit cache\n    print(f'Downloading {fname} from {url}...')\n    r = requests.get(url, stream=True, verify=True)\n    with open(fname, 'wb') as f:\n        f.write(r.content)\n    return fname\n\ndef download_extract(name, folder=None):\n    \"\"\"Download and extract a zip/tar file.\"\"\"\n    fname = download(name)\n    base_dir = os.path.dirname(fname)\n    data_dir, ext = os.path.splitext(fname)\n    if ext == '.zip':\n        fp = zipfile.ZipFile(fname, 'r')\n    elif ext in ('.tar', '.gz'):\n        fp = tarfile.open(fname, 'r')\n    else:\n        assert False, 'Only zip/tar files can be extracted.'\n    fp.extractall(base_dir)\n    return os.path.join(base_dir, folder) if folder else data_dir\n\n\n# + [markdown] id=\"e9vbpUMwTRY1\"\n# # Basics\n#\n# This section is based on sec 8.2 of http://d2l.ai/chapter_recurrent-neural-networks/text-preprocessing.html\n#\n\n# + [markdown] id=\"RMrGxkRNnOx_\"\n# ## Data\n#\n# As a simple example, we use the book \"The Time Machine\" by H G Wells, since it is short (30k words) and public domain.\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"D7OJT7o8nDQN\" outputId=\"2dd7e687-6b9a-48d2-ab49-e1bb5b64d41b\"\nDATA_HUB = dict()\nDATA_URL = 'http://d2l-data.s3-accelerate.amazonaws.com/'\n\nDATA_HUB['time_machine'] = (DATA_URL + 'timemachine.txt',\n                                '090b5e7e70c295757f55df93cb0a180b9691891a')\n\ndef read_time_machine():  \n    \"\"\"Load the time machine dataset into a list of text lines.\"\"\"\n    with open(download('time_machine'), 'r') as f:\n        lines = f.readlines()\n    return [re.sub('[^A-Za-z]+', ' ', line).strip().lower() for line in lines]\n\nlines = read_time_machine()\nprint(f'number of lines: {len(lines)}')\n\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"uCsuaurvnlK8\" outputId=\"8dcf484e-8f45-4748-cc93-c2a2ada427d2\"\nfor i in range(11):\n  print(i, lines[i])\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"btVyl4dItGVT\" outputId=\"6b67aec4-4c26-43f7-ea6e-0c7fd1440f55\"\nnchars = 0\nnwords = 0\nfor i in range(len(lines)):\n  nchars += len(lines[i])\n  words = lines[i].split()\n  nwords += len(words)\nprint('total num characters ', nchars)\nprint('total num words ', nwords)\n\n\n# + [markdown] id=\"KKBbwDcKnwsA\"\n# ## Tokenization\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"X32lM-XvnxhC\" outputId=\"4783ff38-b282-4b0e-fc59-996f6ec0d6a6\"\ndef tokenize(lines, token='word'):  \n    \"\"\"Split text lines into word or character tokens.\"\"\"\n    if token == 'word':\n        return [line.split() for line in lines]\n    elif token == 'char':\n        return [list(line) for line in lines]\n    else:\n        print('ERROR: unknown token type: ' + token)\n\ntokens = tokenize(lines)\nfor i in range(11):\n    print(tokens[i])\n\n\n# + [markdown] id=\"X-Tbg9jjn8XN\"\n# ## Vocabulary\n#\n# We map each word to a unique integer id, sorted by decreasing frequency.\n# We reserve the special id of 0 for the \"unknown word\".\n# We also allow for a list of reserved tokens, such as “pad\" for padding, \"bos\" to present the beginning for a sequence, and “eos” for the end of a sequence.\n#\n\n# + id=\"8ZOLrVNon9dk\"\nclass Vocab:  \n    \"\"\"Vocabulary for text.\"\"\"\n    def __init__(self, tokens=None, min_freq=0, reserved_tokens=None):\n        if tokens is None:\n            tokens = []\n        if reserved_tokens is None:\n            reserved_tokens = []\n        # Sort according to frequencies\n        counter = count_corpus(tokens)\n        self.token_freqs = sorted(counter.items(), key=lambda x: x[1],\n                                  reverse=True)\n        # The index for the unknown token is 0\n        self.unk, uniq_tokens = 0, ['<unk>'] + reserved_tokens\n        uniq_tokens += [\n            token for token, freq in self.token_freqs\n            if freq >= min_freq and token not in uniq_tokens]\n        self.idx_to_token, self.token_to_idx = [], dict()\n        for token in uniq_tokens:\n            self.idx_to_token.append(token)\n            self.token_to_idx[token] = len(self.idx_to_token) - 1\n\n    def __len__(self):\n        return len(self.idx_to_token)\n\n    def __getitem__(self, tokens):\n        if not isinstance(tokens, (list, tuple)):\n            return self.token_to_idx.get(tokens, self.unk)\n        return [self.__getitem__(token) for token in tokens]\n\n    def to_tokens(self, indices):\n        if not isinstance(indices, (list, tuple)):\n            return self.idx_to_token[indices]\n        return [self.idx_to_token[index] for index in indices]\n\ndef count_corpus(tokens):  \n    \"\"\"Count token frequencies.\"\"\"\n    # Here `tokens` is a 1D list or 2D list\n    if len(tokens) == 0 or isinstance(tokens[0], list):\n        # Flatten a list of token lists into a list of tokens\n        tokens = [token for line in tokens for token in line]\n    return collections.Counter(tokens)\n\n\n# + [markdown] id=\"CV0rTlaqoSNE\"\n# Here are the top 10 words (and their codes) in our corpus.\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"tYmbCwY6oUFB\" outputId=\"31a05a85-5113-4db8-aacf-f944f2c576f8\"\nvocab = Vocab(tokens)\nprint(list(vocab.token_to_idx.items())[:10])\n\n# + [markdown] id=\"sKXJQdbXoiqT\"\n# Here is a tokenization of a few sentences.\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"jd73-1zzoUWo\" outputId=\"f2e7dbda-4053-4773-d385-686f6c549144\"\nfor i in [0, 10]:\n    print('words:', tokens[i])\n    print('indices:', vocab[tokens[i]])\n\n\n# + [markdown] id=\"-6LsXchMop3u\"\n# ## Putting it altogether\n#\n# We tokenize the corpus at the character level, and return the sequence of integers, as well as the corresponding Vocab object.\n\n# + id=\"1BywQ9iUoq_D\"\ndef load_corpus_time_machine(max_tokens=-1): \n    \"\"\"Return token indices and the vocabulary of the time machine dataset.\"\"\"\n    lines = read_time_machine()\n    tokens = tokenize(lines, 'char')\n    vocab = Vocab(tokens)\n    # Since each text line in the time machine dataset is not necessarily a\n    # sentence or a paragraph, flatten all the text lines into a single list\n    corpus = [vocab[token] for line in tokens for token in line]\n    if max_tokens > 0:\n        corpus = corpus[:max_tokens]\n    return corpus, vocab\n\n\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"oQzX4Am8osdh\" outputId=\"53318718-5dba-4574-8f7d-3de538584c0d\"\ncorpus, vocab = load_corpus_time_machine()\nlen(corpus), len(vocab)\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"IgDxt_PRovAb\" outputId=\"7aaffeaa-0b08-4796-bce7-e3ef6fe9cc58\"\nprint(corpus[:20])\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"egONc6CRowLa\" outputId=\"030047c5-7199-4000-9e0c-39ba75275fd6\"\nprint(list(vocab.token_to_idx.items())[:10])\n\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"9xKwPjAAozaX\" outputId=\"68c7959c-7bfe-42a1-f324-b9b4a1a90113\"\nprint([vocab.idx_to_token[i] for i in corpus[:20]])\n\n# + [markdown] id=\"X3fLUodCZebY\"\n# ## One-hot encodings\n#\n# We can convert a sequence of N integers into a N*V one-hot matrix, where V is the vocabulary size.\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"Qk21iCFhZj89\" outputId=\"b5323706-52f8-459b-b382-70acbf54ba26\"\nx = torch.tensor(corpus[:3])\nprint(x)\nX = F.one_hot(x, len(vocab))\nprint(X.shape)\nprint(X)\n\n\n# + [markdown] id=\"8vO99OOSuYhX\"\n# # Language modeling\n#\n# When fitting language models, we often need to chop up a long sequence into a set of short sequences, which may be overlapping, as shown below, where we extract subsequences of length $n=5$. \n#\n# <img src=\"https://github.com/probml/pyprobml/blob/master/images/timemachine-5gram.png?raw=true\">\n#\n# Below we show how to do this.\n#\n# This section is based on sec 8.3.4 of\n# http://d2l.ai/chapter_recurrent-neural-networks/language-models-and-dataset.html#reading-long-sequence-data\n#\n\n# + [markdown] id=\"Vert2-4qw5K7\"\n# ## Random ordering\n\n# + [markdown] id=\"_rARqDyZuvlu\"\n# To increase variety of the data, we can start the extraction at a random offset. We can thus create a random sequence data iterator, as follows.\n#\n\n# + id=\"meuw3vkjpL22\"\ndef seq_data_iter_random(corpus, batch_size, num_steps):  \n    \"\"\"Generate a minibatch of subsequences using random sampling.\"\"\"\n    # Start with a random offset (inclusive of `num_steps - 1`) to partition a\n    # sequence\n    corpus = corpus[random.randint(0, num_steps - 1):]\n    # Subtract 1 since we need to account for labels\n    num_subseqs = (len(corpus) - 1) // num_steps\n    # The starting indices for subsequences of length `num_steps`\n    initial_indices = list(range(0, num_subseqs * num_steps, num_steps))\n    # In random sampling, the subsequences from two adjacent random\n    # minibatches during iteration are not necessarily adjacent on the\n    # original sequence\n    random.shuffle(initial_indices)\n\n    def data(pos):\n        # Return a sequence of length `num_steps` starting from `pos`\n        return corpus[pos:pos + num_steps]\n\n    num_batches = num_subseqs // batch_size\n    for i in range(0, batch_size * num_batches, batch_size):\n        # Here, `initial_indices` contains randomized starting indices for\n        # subsequences\n        initial_indices_per_batch = initial_indices[i:i + batch_size]\n        X = [data(j) for j in initial_indices_per_batch]\n        Y = [data(j + 1) for j in initial_indices_per_batch]\n        yield torch.tensor(X), torch.tensor(Y)\n\n\n# + [markdown] id=\"71kdus7mvMFQ\"\n# For example, let us generate a sequence 0,1,..,34, and then extract subsequences of length 5. Each minibatch will have 2 such subsequences, starting at random offsets. There is no ordering between the subsequences, either within or across minibatches. There are $\\lfloor (35-1)/5 \\rfloor = 6$ such subsequences, so the iterator will generate 3 minibatches, each of size 2.\n#\n# For language modeling tasks, we define $X$ to be the first $n-1$ tokens, and $Y$ to be the $n$'th token, which is the one to be predicted.\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"x8GXyqOgvOI7\" outputId=\"efc1667a-624e-461c-a72c-c9d8ac244f81\"\nmy_seq = list(range(35))\nb = 0\nfor X, Y in seq_data_iter_random(my_seq, batch_size=2, num_steps=5):\n    print('batch: ', b)\n    print('X: ', X, '\\nY:', Y)\n    b += 1\n\n\n# + [markdown] id=\"wdg490Gow7la\"\n# ## Sequential ordering\n\n# + [markdown] id=\"55ECVkQLwL8K\"\n# We can also require that the $i$'th subsequence in minibatch $b$ follows the $i$'th subsequence in minibatch $b-1$. This is useful when training RNNs, since when the model encounters batch $b$, the hidden state of the model will already be initialized by the last token in sequence $i$ of batch $b-1$.\n\n# + id=\"r3uVV7lYwCdv\"\ndef seq_data_iter_sequential(corpus, batch_size, num_steps):  \n    \"\"\"Generate a minibatch of subsequences using sequential partitioning.\"\"\"\n    # Start with a random offset to partition a sequence\n    offset = random.randint(0, num_steps)\n    num_tokens = ((len(corpus) - offset - 1) // batch_size) * batch_size\n    Xs = torch.tensor(corpus[offset:offset + num_tokens])\n    Ys = torch.tensor(corpus[offset + 1:offset + 1 + num_tokens])\n    Xs, Ys = Xs.reshape(batch_size, -1), Ys.reshape(batch_size, -1)\n    num_batches = Xs.shape[1] // num_steps\n    for i in range(0, num_steps * num_batches, num_steps):\n        X = Xs[:, i:i + num_steps]\n        Y = Ys[:, i:i + num_steps]\n        yield X, Y\n\n\n# + [markdown] id=\"KGRIkFvXwZX6\"\n# Below we give an example. We see that the first subsequence in batch 1\n# is [0,1,2,3,4], and the first subsequence in batch 2 is [5,6,7,8,9], as desired.\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"aLQzm2qrwY0m\" outputId=\"27a0f0e7-46db-469c-dd1f-906b599be01d\"\nfor X, Y in seq_data_iter_sequential(my_seq, batch_size=2, num_steps=5):\n    print('X: ', X, '\\nY:', Y)\n\n\n# + [markdown] id=\"SP96EBA-w9MF\"\n# ## Data iterator\n# -\n\ndef load_corpus_time_machine(max_tokens=-1):\n    \"\"\"Return token indices and the vocabulary of the time machine dataset.\"\"\"\n    lines = read_time_machine()\n    tokens = tokenize(lines, 'char')\n    vocab = Vocab(tokens)\n    # Since each text line in the time machine dataset is not necessarily a\n    # sentence or a paragraph, flatten all the text lines into a single list\n    corpus = [vocab[token] for line in tokens for token in line]\n    if max_tokens > 0:\n        corpus = corpus[:max_tokens]\n    return corpus, vocab\n\n\n# + id=\"IpjIv8tMw-QD\"\nclass SeqDataLoader:  #@save\n    \"\"\"An iterator to load sequence data.\"\"\"\n    def __init__(self, batch_size, num_steps, use_random_iter, max_tokens):\n        if use_random_iter:\n            self.data_iter_fn = seq_data_iter_random\n        else:\n            self.data_iter_fn = seq_data_iter_sequential\n        self.corpus, self.vocab = load_corpus_time_machine(max_tokens)\n        self.batch_size, self.num_steps = batch_size, num_steps\n\n    def __iter__(self):\n        return self.data_iter_fn(self.corpus, self.batch_size, self.num_steps)\n\n\n# + id=\"pIy_YUk9w-0A\"\ndef load_data_time_machine(batch_size, num_steps,  #@save\n                           use_random_iter=False, max_tokens=10000):\n    \"\"\"Return the iterator and the vocabulary of the time machine dataset.\"\"\"\n    data_iter = SeqDataLoader(batch_size, num_steps, use_random_iter,\n                              max_tokens)\n    return data_iter, data_iter.vocab\n\n\n# + id=\"Y44o8-MkxA3t\"\ndata_iter, vocab = load_data_time_machine(2, 5)\n\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"sf-py0roxmAC\" outputId=\"66691d42-4905-4fe3-b906-8856e525665b\"\nprint(list(vocab.token_to_idx.items())[:10])\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"6XhwWfMHxXTA\" outputId=\"a29066f2-d2e2-447c-d290-ea473ecc0ee1\"\nb = 0\nfor X, Y in data_iter:\n    print('batch: ', b)\n    print('X: ', X, '\\nY:', Y)\n    b += 1\n    if b > 2:\n      break\n\n# + [markdown] id=\"yDmK1xQ9T4IY\"\n# # Machine translation\n#\n# When dealing with sequence-to-sequence tasks, such as NMT, we need to create a vocabulary for the source and target language. In addition, the input and output sequences may have different lengths, so we need to use padding to ensure that we can create fixed-size minibatches. We show how to do this below.\n#\n# This is based on sec 9.5 of \n# http://d2l.ai/chapter_recurrent-modern/machine-translation-and-dataset.html\n#\n#\n#\n\n# + [markdown] id=\"gBUgcAcmUdCJ\"\n# ## Data\n#\n# We use an English-French dataset that consists of bilingual sentence pairs from the [Tatoeba Project](http://www.manythings.org/anki/). Each line in the dataset is a tab-delimited pair of an English text sequence (source) and the translated French text sequence (target).\n#\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"UnjXAtdYUUW8\" outputId=\"66c19d66-217b-43ef-9877-854ea32725d0\"\nDATA_HUB['fra-eng'] = (DATA_URL + 'fra-eng.zip',\n                           '94646ad1522d915e7b0f9296181140edcf86a4f5')\n\ndef read_data_nmt():\n    \"\"\"Load the English-French dataset.\"\"\"\n    data_dir = download_extract('fra-eng')\n    with open(os.path.join(data_dir, 'fra.txt'), 'r') as f:\n        return f.read()\n\nraw_text = read_data_nmt()\nprint(raw_text[:100])\n\n\n# + [markdown] id=\"sqZImjzDVMHa\"\n# ## Preprocessing\n#\n# We apply several preprocessing steps: we replace non-breaking space with space, convert uppercase letters to lowercase ones, and insert space between words and punctuation marks.\n#\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"r5ZUH4ZaUquY\" outputId=\"316a660f-1d3a-45e4-ddb2-f97ed3128733\"\ndef preprocess_nmt(text):\n    \"\"\"Preprocess the English-French dataset.\"\"\"\n    def no_space(char, prev_char):\n        return char in set(',.!?') and prev_char != ' '\n\n    # Replace non-breaking space with space, and convert uppercase letters to\n    # lowercase ones\n    text = text.replace('\\u202f', ' ').replace('\\xa0', ' ').lower()\n    # Insert space between words and punctuation marks\n    out = [\n        ' ' + char if i > 0 and no_space(char, text[i - 1]) else char\n        for i, char in enumerate(text)]\n    return ''.join(out)\n\ntext = preprocess_nmt(raw_text)\nprint(text[:110])\n\n\n# + [markdown] id=\"yGChAGPjVgUn\"\n# We tokenize at the word level.  The following tokenize_nmt function tokenizes the the first `num_examples` text sequence pairs, where each token is either a word or a punctuation mark. \n\n# + id=\"PZ-iR79zVKM_\"\ndef tokenize_nmt(text, num_examples=None):\n    \"\"\"Tokenize the English-French dataset.\"\"\"\n    source, target = [], []\n    for i, line in enumerate(text.split('\\n')):\n        if num_examples and i > num_examples:\n            break\n        parts = line.split('\\t')\n        if len(parts) == 2:\n            source.append(parts[0].split(' '))\n            target.append(parts[1].split(' '))\n    return source, target\n\n\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"v282HIgRVfza\" outputId=\"12cafea1-eee6-43e9-ba8d-79c6ef5affc2\"\nsource, target = tokenize_nmt(text)\nsource[:10], target[:10]\n\n# + [markdown] id=\"LC8u2YndV6-P\"\n# ## Vocabulary\n#\n# We can make a source and target vocabulary. To avoid having too many unique tokens, we specify a minimum frequency of 2 - all others will get replaced by \"unk\". We also add special tags for padding, begin of sentence, and end of sentence.\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"v9SrJQc3VtSn\" outputId=\"8b0e6cd5-890d-46c5-ce79-14f256ba63b3\"\nsrc_vocab = Vocab(source, min_freq=2,\n                      reserved_tokens=['<pad>', '<bos>', '<eos>'])\nlen(src_vocab)\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"KPF2FthfV840\" outputId=\"f08bca8e-8564-411d-e58f-6e5b2e19f671\"\n# French has more high frequency words than English\ntarget_vocab = Vocab(target, min_freq=2,\n                      reserved_tokens=['<pad>', '<bos>', '<eos>'])\nlen(target_vocab)\n\n\n# + [markdown] id=\"d0DyArAtWcob\"\n# ## Truncation and padding\n#\n# To create minibatches of sequences, all of the same length, we truncate sentences that are too long, and pad ones that are too short.\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"x2D62tczWP-2\" outputId=\"25ca1de2-97a6-4273-abbf-644a41562bb8\"\ndef truncate_pad(line, num_steps, padding_token):\n    \"\"\"Truncate or pad sequences.\"\"\"\n    if len(line) > num_steps:\n        return line[:num_steps]  # Truncate\n    return line + [padding_token] * (num_steps - len(line))  # Pad\n\nprint(truncate_pad(source[0], 10, 'pad'))\nprint(truncate_pad(src_vocab[source[0]], 10, src_vocab['<pad>']))\n\n\n# + id=\"RgyPxL6tWvJC\"\ndef build_array_nmt(lines, vocab, num_steps):\n    \"\"\"Transform text sequences of machine translation into minibatches.\"\"\"\n    lines = [vocab[l] for l in lines]\n    lines = [l + [vocab['<eos>']] for l in lines]\n    array = torch.tensor([\n        truncate_pad(l, num_steps, vocab['<pad>']) for l in lines])\n    valid_len = (array != vocab['<pad>']).type(torch.int32).sum(1)\n    return array, valid_len\n\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"SlwULfBwW9ma\" outputId=\"51eae96b-bfd0-4325-93ef-c98315abb6b0\"\nnum_steps = 10\nsrc_array, src_valid_len = build_array_nmt(source, src_vocab, num_steps)\nprint(src_array.shape)\nprint(src_valid_len.shape)\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"br6L3nDbXFHY\" outputId=\"e70924a1-6e71-49dc-b393-364feac92296\"\nprint(src_array[0,:]) # go, ., eos, pad, ..., pad\nprint(src_valid_len[0])\n\n\n# + [markdown] id=\"UyXmgFUvXVnA\"\n# ## Data iterator\n#\n# Below we combine all of the above pieces into a handy function.\n\n# + id=\"AkD1QMiJXKAP\"\ndef load_array(data_arrays, batch_size, is_train=True):\n    \"\"\"Construct a PyTorch data iterator.\"\"\"\n    dataset = data.TensorDataset(*data_arrays)\n    return data.DataLoader(dataset, batch_size, shuffle=is_train)\n    \ndef load_data_nmt(batch_size, num_steps, num_examples=600):\n    \"\"\"Return the iterator and the vocabularies of the translation dataset.\"\"\"\n    text = preprocess_nmt(read_data_nmt())\n    source, target = tokenize_nmt(text, num_examples)\n    src_vocab = Vocab(source, min_freq=2,\n                          reserved_tokens=['<pad>', '<bos>', '<eos>'])\n    tgt_vocab = Vocab(target, min_freq=2,\n                          reserved_tokens=['<pad>', '<bos>', '<eos>'])\n    src_array, src_valid_len = build_array_nmt(source, src_vocab, num_steps)\n    tgt_array, tgt_valid_len = build_array_nmt(target, tgt_vocab, num_steps)\n    data_arrays = (src_array, src_valid_len, tgt_array, tgt_valid_len)\n    data_iter = load_array(data_arrays, batch_size)\n    return data_iter, src_vocab, tgt_vocab\n\n\n# + [markdown] id=\"ARsiX21oXdOd\"\n# Show the first minibatch.\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"vl00eydyXeYF\" outputId=\"a48df679-efd7-4e87-b3cd-fb66689e56e0\"\ntrain_iter, src_vocab, tgt_vocab = load_data_nmt(batch_size=2, num_steps=8)\nfor X, X_valid_len, Y, Y_valid_len in train_iter:\n    print('X:', X.type(torch.int32))\n    print('valid lengths for X:', X_valid_len)\n    print('Y:', Y.type(torch.int32))\n    print('valid lengths for Y:', Y_valid_len)\n    break\n\n# + id=\"thnQxtaIXenj\"\n\n", "meta": {"hexsha": "6f9c133fe3047da2ae552e8f881ceddad40be1e0", "size": 22494, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks-text-format/text_preproc_torch.py", "max_stars_repo_name": "arpitvaghela/probml-notebooks", "max_stars_repo_head_hexsha": "32ecb309dd474b989fd1c6ce4ad6dab7a25bbead", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 166, "max_stars_repo_stars_event_min_datetime": "2021-07-16T17:33:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T03:35:34.000Z", "max_issues_repo_path": "notebooks-text-format/text_preproc_torch.py", "max_issues_repo_name": "arpitvaghela/probml-notebooks", "max_issues_repo_head_hexsha": "32ecb309dd474b989fd1c6ce4ad6dab7a25bbead", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 29, "max_issues_repo_issues_event_min_datetime": "2021-07-21T16:31:51.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T19:50:13.000Z", "max_forks_repo_path": "notebooks-text-format/text_preproc_torch.py", "max_forks_repo_name": "arpitvaghela/probml-notebooks", "max_forks_repo_head_hexsha": "32ecb309dd474b989fd1c6ce4ad6dab7a25bbead", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 48, "max_forks_repo_forks_event_min_datetime": "2021-07-17T08:26:18.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T03:36:18.000Z", "avg_line_length": 38.1254237288, "max_line_length": 374, "alphanum_fraction": 0.6814706144, "include": true, "reason": "import numpy", "num_tokens": 6663, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.2782567817320044, "lm_q2_score": 0.1919327864472368, "lm_q1q2_score": 0.05340659946566419}}
{"text": "#!/usr/bin/env python\nu\"\"\"\nreanalysis_geopotential_heights.py\nWritten by Tyler Sutterley (10/2021)\nReads temperature and specific humidity data to calculate geopotential height\n    and pressure difference fields at half levels from reanalysis\n\nINPUTS:\n    Reanalysis model to run\n    ERA-Interim: http://apps.ecmwf.int/datasets/data/interim-full-moda\n    ERA5: http://apps.ecmwf.int/data-catalogues/era5/?class=ea\n    MERRA-2: https://gmao.gsfc.nasa.gov/reanalysis/MERRA-2/\n\nCOMMAND LINE OPTIONS:\n    -D X, --directory X: Working data directory\n    -Y X, --year X: years to run\n    -V, --verbose: Output information for each output file\n    -M X, --mode X: Permission mode of directories and files\n\nPYTHON DEPENDENCIES:\n    numpy: Scientific Computing Tools For Python\n        https://numpy.org\n        https://numpy.org/doc/stable/user/numpy-for-matlab-users.html\n    netCDF4: Python interface to the netCDF C library\n        https://unidata.github.io/netcdf4-python/netCDF4/index.html\n\nPROGRAM DEPENDENCIES:\n    utilities.py: download and management utilities for files\n\nUPDATE HISTORY:\n    Updated 10/2021: using python logging for handling verbose output\n    Updated 07/2021: can use input files to define command line arguments\n        added check for ERA5 expver dimension (denotes mix of ERA5 and ERA5T)\n    Updated 05/2021: define int/float precision to prevent deprecation warning\n    Updated 03/2021: automatically update years to run based on current time\n    Updated 01/2021: read from netCDF4 file in slices to reduce memory load\n    Updated 12/2020: using argparse to set command line options\n    Updated 01/2020: outputs variables as 32-bit floats instead of 64-bit floats\n        clear variables and iterate years to reduce required memory\n        iterate over time variable to calculate heights using incomplete files\n    Updated 08/2019: adjust time scale variable for MERRA-2\n    Updated 07/2018: added parameters for ERA5\n    Written 03/2018\n\"\"\"\nfrom __future__ import print_function\n\nimport os\nimport re\nimport time\nimport logging\nimport netCDF4\nimport argparse\nimport numpy as np\nimport gravity_toolkit.utilities as utilities\n\n#-- PURPOSE: reads temperature and specific humidity data to calculate\n#-- geopotential height fields at half levels from reanalysis\ndef reanalysis_geopotential_heights(base_dir, MODEL, YEAR=None,\n    VERBOSE=False, MODE=0o775):\n\n    #-- create logger for verbosity level\n    loglevel = logging.INFO if VERBOSE else logging.CRITICAL\n    logging.basicConfig(level=loglevel)\n\n    #-- directory setup\n    ddir = os.path.join(base_dir,MODEL)\n    #-- set model specific parameters\n    if (MODEL == 'ERA-Interim'):\n        #-- invariant parameters file\n        input_invariant_file = 'ERA-Interim-Invariant-Parameters.nc'\n        #-- coordinate parameters file\n        input_coordinate_file = 'ERA-Interim_coordvars.nc'\n        #-- surface pressure file format\n        input_pressure_file = 'ERA-Interim-Monthly-SP-{0:4d}.nc'\n        #-- regular expression pattern for finding files\n        regex_pattern = r'ERA\\-Interim\\-Monthly\\-Levels\\-({0})\\.nc$'\n        #-- output file format\n        output_file_format = 'ERA-Interim-GPH-Levels-{0:4d}.nc'\n        SURFNAME = 'z'\n        ZNAME = 'z'\n        VARNAME = 'sp'\n        TNAME = 't'\n        QNAME = 'q'\n        DIFFNAME = 'dp'\n        LONNAME = 'longitude'\n        LATNAME = 'latitude'\n        TIMENAME = 'time'\n        LEVELNAME = 'lvl'\n        ANAME,BNAME = ('a_model_alt','b_model_alt')\n        AINTERFACE,BINTERFACE = ('a_interface','b_interface')\n        #-- hours since 1900-01-01 00:00:0.0\n        TIME_LONGNAME = 'Time'\n        UNITS = 'm**2 s**-2'\n        GRAVITY = 1.0\n    elif (MODEL == 'ERA5'):\n        #-- invariant parameters file\n        input_invariant_file = 'ERA5-Invariant-Parameters.nc'\n        #-- coordinate parameters file\n        input_coordinate_file = 'ERA5_coordvars.nc'\n        #-- surface pressure file format\n        input_pressure_file = 'ERA5-Monthly-SP-{0:4d}.nc'\n        #-- regular expression pattern for finding files\n        regex_pattern = r'ERA5\\-Monthly\\-Levels\\-({0})\\.nc$'\n        #-- output file format\n        output_file_format = 'ERA5-GPH-Levels-{0:4d}.nc'\n        SURFNAME = 'z'\n        ZNAME = 'z'\n        VARNAME = 'sp'\n        TNAME = 't'\n        QNAME = 'q'\n        DIFFNAME = 'dp'\n        LONNAME = 'longitude'\n        LATNAME = 'latitude'\n        TIMENAME = 'time'\n        LEVELNAME = 'lvl'\n        ANAME,BNAME = ('a_half','b_half')\n        AINTERFACE,BINTERFACE = ('a_interface','b_interface')\n        #-- hours since 1900-01-01 00:00:0.0\n        TIME_LONGNAME = 'Time'\n        UNITS = 'm**2 s**-2'\n        GRAVITY = 1.0\n    elif (MODEL == 'MERRA-2'):\n        #-- invariant parameters file\n        input_invariant_file = 'MERRA2_101.const_2d_asm_Nx.00000000.nc4'\n        #-- coordinate parameters file\n        input_coordinate_file = 'MERRA2_101.Coords_Nx.00000000.nc'\n        #-- regular expression pattern for finding files\n        regex_pattern = r'MERRA2_(\\d+).instM_3d_ana_Nv.({0})(\\d{{2}}).SUB.nc$'\n        #-- output file format\n        output_file_format='MERRA2_{0:0.0f}.GPH_levels.{1:4.0f}{2:02.0f}.SUB.nc'\n        SURFNAME = 'PHIS'\n        ZNAME = 'PHIS'\n        VARNAME = 'PS'\n        TNAME = 'T'\n        QNAME = 'QV'\n        DIFFNAME = 'dP'\n        LONNAME = 'lon'\n        LATNAME = 'lat'\n        TIMENAME = 'time'\n        LEVELNAME = 'lev'\n        ANAME,BNAME = ('a_half','b_half')\n        AINTERFACE,BINTERFACE = ('a_interface','b_interface')\n        #-- minutes since start of file\n        TIME_LONGNAME = 'Time'\n        UNITS = 'm+2 s-2'\n        GRAVITY = 1.0\n\n    #-- read model orography for dimensions\n    geopotential,lon,lat=ncdf_invariant(os.path.join(ddir,input_invariant_file),\n        LONNAME,LATNAME,SURFNAME)\n    #-- read parameters for calculating pressures at levels\n    lev,A,B,AI,BI=ncdf_coordinates(os.path.join(ddir,input_coordinate_file),\n        LEVELNAME,ANAME,BNAME,AINTERFACE,BINTERFACE)\n    #-- Gas constant for dry air\n    R_dry = 287.06\n\n    #-- read each reanalysis pressure field for each year\n    regex_years = r'\\d{4}' if (YEAR is None) else '|'.join(map(str,YEAR))\n    rx = re.compile(regex_pattern.format(regex_years), re.VERBOSE)\n    input_files = [fi for fi in os.listdir(ddir) if rx.match(fi)]\n    #-- for each reanalysis file\n    for fi in sorted(input_files):\n        #-- read input temperature and specific humidity data\n        fid1 = netCDF4.Dataset(os.path.join(ddir,fi),'r')\n        #-- extract shape from temperature variable\n        ntime,nlevels,nlat,nlon = fid1.variables[TNAME].shape\n        #-- invalid value\n        fill_value = fid1.variables[TNAME]._FillValue\n        #-- save output variables into a python dictionary.\n        dinput = {}\n        dinput[ZNAME] = np.zeros((ntime,nlevels,nlat,nlon),dtype=np.float32)\n        dinput[DIFFNAME] = np.zeros((ntime,nlevels,nlat,nlon),dtype=np.float32)\n        #-- model levels in reverse order\n        dinput[LEVELNAME] = lev[::-1].copy()\n        #-- extract time and time units\n        dinput[TIMENAME] = np.copy(fid1.variables[TIMENAME][:])\n        TIME_UNITS = fid1.variables[TIMENAME].units\n        dinput[LONNAME] = lon.copy()\n        dinput[LATNAME] = lat.copy()\n\n        if MODEL in ('MERRA-2'):\n            #-- extract date from monthly files\n            MOD,YEAR,MONTH = np.array(rx.findall(fi).pop(), dtype=np.float64)\n            #-- output monthly filename\n            FILE = os.path.join(ddir,output_file_format.format(MOD,YEAR,MONTH))\n            #-- read surface pressure\n            surface_pressure = np.copy(fid1.variables[VARNAME][:])\n        elif MODEL in ('ERA-Interim','ERA5'):\n            #-- extract year from file name\n            YEAR, = np.array(rx.findall(fi),dtype=np.int64)\n            #-- output yearly filename\n            FILE = os.path.join(ddir,output_file_format.format(YEAR))\n            #-- read input surface pressure data\n            pressure_file = input_pressure_file.format(YEAR)\n            with netCDF4.Dataset(os.path.join(ddir,pressure_file),'r') as fid2:\n                surface_pressure = np.copy(fid2.variables[VARNAME][:])\n\n        #-- iterate over dates\n        for t in range(ntime):\n            #-- check dimensions for expver slice\n            if (fid1.variables[VARNAME].ndim == 5):\n                t_time,q_time = ncdf_expver(fid1,t,TNAME,QNAME)\n            else:\n                #-- temperature and specific humidity\n                #-- reverse layers so bottom=0\n                t_time = fid1.variables[TNAME][t,::-1,:,:]\n                q_time = fid1.variables[QNAME][t,::-1,:,:]\n            #-- calculate geopotential over model levels\n            geopotential_height = np.empty((nlat,nlon),dtype=np.float32)\n            #-- start with surface geopotential converted to units (m^2/s^2)\n            geopotential_height[:,:] = geopotential*GRAVITY\n            #-- Integrate the model layers in the atmosphere\n            for k in range(nlevels):\n                #-- calculate virtual temperature\n                virtual_temp = (1.0 + 0.609133*q_time[k,:,:])*t_time[k,:,:]\n                #-- calculate numerator and denominator for pressure ratio\n                Pnum = A[k] + B[k]*surface_pressure[t,:,:]\n                if ((k+1) == nlevels):\n                    Pdom = 0.1\n                else:\n                    Pdom = A[k+1] + B[k+1]*surface_pressure[t,:,:]\n                #-- add level to geopotential_levels\n                geopotential_height[:,:] += R_dry*virtual_temp*np.log(Pnum/Pdom)\n                #-- save level to output variable and convert to output units\n                dinput[ZNAME][t,k,:,:] = geopotential_height/GRAVITY\n                #-- calculate pressure difference between levels (at interfaces)\n                Plower = AI[k] + BI[k]*surface_pressure[t,:,:]\n                Pupper = AI[k+1] + BI[k+1]*surface_pressure[t,:,:]\n                dinput[DIFFNAME][t,k,:,:] = Pupper - Plower\n\n        #-- save to file\n        ncdf_geopotential_write(dinput, fill_value, FILENAME=FILE, ZNAME=ZNAME,\n            LEVELNAME=LEVELNAME, DIFFNAME=DIFFNAME, LONNAME=LONNAME,\n            LATNAME=LATNAME, TIMENAME=TIMENAME, TIME_UNITS=TIME_UNITS,\n            TIME_LONGNAME=TIME_LONGNAME, UNITS=UNITS)\n        #-- set the permissions level of the output file to MODE\n        os.chmod(FILE, MODE)\n        #-- clear dinput dictionary variable\n        dinput = None\n        #-- close the input netCDF4 file\n        fid1.close()\n\n#-- PURPOSE: Compute the Specific Humidity from parameters (Bolton 1980)\n#-- http://cires1.colorado.edu/~voemel/vp.html\n#-- https://www.eol.ucar.edu/projects/ceop/dm/documents/refdata_report/eqns.html\n#-- https://github.com/NCAR/ncl/blob/master/ni/src/lib/nfpfort/mixhum_ptrh.f\ndef calculate_specific_humidity(P, T, RH):\n    #-- ratio of the molecular weights of water vapor to dry air\n    epsilon = 0.622\n    #-- calibration pressure and temperature\n    pc = 6.112\n    tc = 243.5\n    #-- calculate the saturation vapor pressure in mb\n    Es = pc * np.exp((17.67 * T)/(T + tc))\n    #-- calculate the vapor pressure in mb\n    Ev = Es * (RH/100.0)\n    #-- calculate the dew point temperature\n    Td = np.log(Ev/pc) * tc/(17.67 - np.log(Ev/pc))\n    #-- calculate the specific humidity\n    Q = (epsilon * Ev)/(P/100.0 - (0.378 * Ev))\n    return (Q,Td)\n\n#-- PURPOSE: extract temperature and specific humidity variables\n#-- from a 5d netCDF4 dataset\n#-- ERA5 expver dimension (denotes mix of ERA5 and ERA5T)\ndef ncdf_expver(fileID, slice, TNAME, QNAME):\n    ntime,nexp,nlevel,nlat,nlon = fileID.variables[TNAME].shape\n    fill_value = fileID.variables[TNAME]._FillValue\n    #-- reduced temperature and specific humidity for time\n    temperature = np.ma.zeros((nlevel,nlat,nlon))\n    temperature.fill_value = fill_value\n    humidity = np.ma.zeros((nlevel,nlat,nlon))\n    humidity.fill_value = fill_value\n    #-- iterate over expver slices to find valid outputs\n    for j in range(nexp):\n        #-- check if any are valid for expver\n        if np.any(fileID.variables[TNAME][slice,j,:,:,:]):\n            #-- reverse layers so bottom=0\n            temperature[:,:,:] = fileID.variables[TNAME][slice,j,::-1,:,:]\n            humidity[:,:,:] = fileID.variables[QNAME][slice,j,::-1,:,:]\n    #-- update mask variables\n    temperature.mask = (temperature.data == temperature.fill_value)\n    humidity.mask = (humidity.data == humidity.fill_value)\n    #-- return the reduced temperature and specific humidity variables\n    return (temperature,humidity)\n\n#-- PURPOSE: read reanalysis invariant parameters (geopotential,lat,lon)\ndef ncdf_invariant(FILENAME,LONNAME,LATNAME,ZNAME):\n    with netCDF4.Dataset(FILENAME,'r') as fileID:\n        geopotential = fileID.variables[ZNAME][:].squeeze()\n        longitude = fileID.variables[LONNAME][:].copy()\n        latitude = fileID.variables[LATNAME][:].copy()\n    return (geopotential,longitude,latitude)\n\n#-- PURPOSE: read reanalysis coordinate parameters\n#-- reverse order to go from surface to top-of-atmosphere\ndef ncdf_coordinates(FILENAME,LEVELNAME,ANAME,BNAME,AINTERFACE,BINTERFACE):\n    with netCDF4.Dataset(FILENAME,'r') as fileID:\n        levels = fileID.variables[LEVELNAME][:].copy()\n        A = fileID.variables[ANAME][::-1].copy()\n        B = fileID.variables[BNAME][::-1].copy()\n        AI = fileID.variables[AINTERFACE][::-1].copy()\n        BI = fileID.variables[BINTERFACE][::-1].copy()\n    return (levels,A,B,AI,BI)\n\n#-- PURPOSE: write output geopotential fields data to file\ndef ncdf_geopotential_write(dinput, fill_value, FILENAME=None, ZNAME=None,\n    DIFFNAME=None, LEVELNAME=None, LONNAME=None, LATNAME=None, TIMENAME=None,\n    TIME_UNITS=None, TIME_LONGNAME=None, UNITS=None):\n    #-- opening NetCDF file for writing\n    fileID = netCDF4.Dataset(FILENAME, 'w', format=\"NETCDF4\")\n\n    #-- Defining the NetCDF dimensions\n    for key in [LONNAME,LATNAME,TIMENAME,LEVELNAME]:\n        fileID.createDimension(key, len(dinput[key]))\n\n    #-- defining the NetCDF variables\n    nc = {}\n    nc[LATNAME]=fileID.createVariable(LATNAME,dinput[LATNAME].dtype,(LATNAME,))\n    nc[LONNAME]=fileID.createVariable(LONNAME,dinput[LONNAME].dtype,(LONNAME,))\n    nc[TIMENAME]=fileID.createVariable(TIMENAME,dinput[TIMENAME].dtype,(TIMENAME,))\n    nc[LEVELNAME]=fileID.createVariable(LEVELNAME,dinput[LEVELNAME].dtype,(LEVELNAME,))\n    nc[DIFFNAME] = fileID.createVariable(DIFFNAME, dinput[DIFFNAME].dtype,\n        (TIMENAME,LEVELNAME,LATNAME,LONNAME,), fill_value=fill_value, zlib=True)\n    nc[ZNAME] = fileID.createVariable(ZNAME, dinput[ZNAME].dtype,\n        (TIMENAME,LEVELNAME,LATNAME,LONNAME,), fill_value=fill_value, zlib=True)\n    #-- filling NetCDF variables\n    for key,val in dinput.items():\n        nc[key][:] = dinput[key].copy()\n        dinput[key] = None\n\n    #-- Defining attributes for longitude and latitude\n    nc[LONNAME].long_name = 'Longitude'\n    nc[LONNAME].units = 'degrees_east'\n    nc[LATNAME].long_name = 'Latitude'\n    nc[LATNAME].units = 'degrees_north'\n    #-- Defining attributes for time\n    nc[TIMENAME].units = TIME_UNITS\n    nc[TIMENAME].long_name = TIME_LONGNAME\n    #-- Definining attributes for model levels\n    nc[LEVELNAME].long_name = 'Model_Level_Number'\n    #-- Defining attributes for geopotential height\n    nc[ZNAME].long_name = 'Geopotential_Heights_on_Model_Levels'\n    nc[ZNAME].units = UNITS\n    #-- Defining attributes for pressure differences\n    nc[DIFFNAME].long_name = 'Pressure_Differences_between_Levels'\n    nc[DIFFNAME].units = 'Pa'\n\n    #-- Output NetCDF structure information\n    logging.info(os.path.basename(FILENAME))\n    logging.info(list(fileID.variables.keys()))\n\n    #-- Closing the NetCDF file\n    fileID.close()\n    #-- clear nc dictionary variable\n    nc = None\n\n#-- Main program that calls reanalysis_geopotential_heights()\ndef main():\n    #-- Read the system arguments listed after the program\n    parser = argparse.ArgumentParser(\n        description=\"\"\"Reads temperature and specific humidity data\n            to calculate geopotential height and pressure difference\n            fields at half levels from reanalysis\n            \"\"\",\n        fromfile_prefix_chars=\"@\"\n    )\n    parser.convert_arg_line_to_args = utilities.convert_arg_line_to_args\n    #-- command line parameters\n    choices = ['ERA-Interim','ERA5','MERRA-2']\n    parser.add_argument('model',\n        metavar='MODEL', type=str, nargs='+',\n        default=['ERA5','MERRA-2'], choices=choices,\n        help='Reanalysis Model')\n    #-- working data directory\n    parser.add_argument('--directory','-D',\n        type=lambda p: os.path.abspath(os.path.expanduser(p)),\n        default=os.getcwd(),\n        help='Working data directory')\n    #-- years to run\n    now = time.gmtime()\n    parser.add_argument('--year','-Y',\n        type=int, nargs='+', default=range(2000,now.tm_year+1),\n        help='Years of model outputs to run')\n    #-- print information about each input and output file\n    parser.add_argument('--verbose','-V',\n        default=False, action='store_true',\n        help='Verbose output of run')\n    #-- permissions mode of the local directories and files (number in octal)\n    parser.add_argument('--mode','-M',\n        type=lambda x: int(x,base=8), default=0o775,\n        help='Permission mode of directories and files')\n    args,_ = parser.parse_known_args()\n\n    #-- for each reanalysis model\n    for MODEL in args.model:\n        #-- run program\n        reanalysis_geopotential_heights(args.directory, MODEL, YEAR=args.year,\n            VERBOSE=args.verbose, MODE=args.mode)\n\n#-- run main program\nif __name__ == '__main__':\n    main()\n", "meta": {"hexsha": "ec0705f0e521ee901b5afb8d070c62d4826e98a5", "size": 17577, "ext": "py", "lang": "Python", "max_stars_repo_path": "reanalysis/reanalysis_geopotential_heights.py", "max_stars_repo_name": "tsutterley/model-harmonics", "max_stars_repo_head_hexsha": "17f6842d5fa1f2abf42caea51cfb09b6a4b2ee30", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-01-04T00:40:03.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-29T13:37:32.000Z", "max_issues_repo_path": "reanalysis/reanalysis_geopotential_heights.py", "max_issues_repo_name": "tsutterley/model-harmonics", "max_issues_repo_head_hexsha": "17f6842d5fa1f2abf42caea51cfb09b6a4b2ee30", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-10-10T06:57:20.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-06T19:28:34.000Z", "max_forks_repo_path": "reanalysis/reanalysis_geopotential_heights.py", "max_forks_repo_name": "tsutterley/model-harmonics", "max_forks_repo_head_hexsha": "17f6842d5fa1f2abf42caea51cfb09b6a4b2ee30", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2021-05-18T21:00:59.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-06T18:22:58.000Z", "avg_line_length": 43.5074257426, "max_line_length": 87, "alphanum_fraction": 0.6490299824, "include": true, "reason": "import numpy", "num_tokens": 4584, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO\n\n", "lm_q1_score": 0.5, "lm_q2_score": 0.1066905825840872, "lm_q1q2_score": 0.0533452912920436}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     formats: ipynb,py:light\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.5'\n#       jupytext_version: 1.11.3\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# # 2021 Oceanography Camp for Girls Saildrone Lesson\n# Developed by Nancy Williams, Veronica Tamsitt, Nicola Guisewhite at University of South Florida College of Marine Science\n\n# ## To Do List:\n# * remove all fronts except SAF and SBDY for simplicity\n# * make a function for plotting instead of copy/pasting the map each time (or not, if we want to keep it simple)\n# * add more markdown in the form of instructions, pictures, pulling variables out into their own cell so girls know where they can make changes to the code\n# * in figure titles and filenames, change the variables from using the first four characters (currently var[:4]) to instead cutting off at the first underscore\n# * try plotting previous 8-day chl-a snapshot to see if it has better coverage for the eddy crossing\n# * edit to make it easy to adjust time series x-axis limits\n# * Check Veronica's carbon flux calculation is correct (Nancy)\n\n\n# ## Data Sources:\n# * (too big for Binder so had to remove it) Saildrone 1-minute physical and ADCP data available from: https://data.saildrone.com/data/sets/antarctica-circumnavigation-2019\n# (login required, so cannot be accessed using an FTP. Will need to download ahead)\n# * Saildrone hourly-ish CO2, pH, and physical data available from: https://www.ncei.noaa.gov/access/metadata/landing-page/bin/iso?id=gov.noaa.nodc:0221912\n# * Satellite Chlorophyll: https://neo.sci.gsfc.nasa.gov/view.php?datasetId=MY1DMW_CHLORA&year=2019\n# * SSH: https://cds.climate.copernicus.eu/cdsapp#!/dataset/satellite-sea-level-global?tab=overview \n# (login required for chla and SSH, download ahead of time. Can also be downloaded using motuclient, login also required https://github.com/clstoulouse/motu-client-python)\n\n# +\n# Import the tools you need\nimport os\nimport numpy as np\nimport pandas as pd\nimport datetime as dt\nimport xarray as xr\nimport matplotlib.pyplot as plt\nimport matplotlib.path as mpath\nimport cartopy.crs as ccrs\nimport cartopy.feature\nfrom datetime import datetime\n\n# add something\n# -\n\n# Set the paths\noutput_dir = 'Output/'\ndata_dir = 'Data/'\n\n# Go and download the hourly Saildrone CO2 data and put it in the `Data/` folder\nos.chdir(data_dir) # Change the directory to the `Data/` folder\nos.getcwd() # Check that you're now in the `Data/` folder\n# Curl downloads the data files directly from the web and shows you the status while it works. \n# `!` at the beginning of the line tells you that this command is a unix shell command (not python code)\n# ! curl -o 32DB20190119_ASV_Saildrone1020_Antarctic_Jan2019_Aug2019.csv https://www.ncei.noaa.gov/data/oceans/ncei/ocads/data/0221912/32DB20190119_ASV_Saildrone1020_Antarctic_Jan2019_Aug2019.csv\nos.chdir(\"..\") # Use \"..\" to move back up one directory now that we've imported the MLD climatology data\n\n# Import the hourly Saildrone CO2 data file\nSaildrone_CO2 = pd.read_csv(\n    (data_dir + '32DB20190119_ASV_Saildrone1020_Antarctic_Jan2019_Aug2019.csv'),\n    header=4,\n    na_values=-999,\n)\n\n# Create a datetime object\nSaildrone_CO2['datetime'] = pd.to_datetime(Saildrone_CO2['Date'] + ' ' + Saildrone_CO2['Time'])\n# Check that the Saildrone data was imported correctly\nSaildrone_CO2\n\n# Import the Southern Ocean fronts for mapping\nstf = pd.read_csv(data_dir + 'fronts/stf.txt', header=None, sep='\\s+', \n                  na_values='%', names=['lon','lat'])\nsaf = pd.read_csv(data_dir + 'fronts/saf.txt', header=None, sep='\\s+', \n                  na_values='%', names=['lon','lat'])\npf = pd.read_csv(data_dir + 'fronts/pf.txt', header=None, sep='\\s+', \n                 na_values='%', names=['lon','lat'])\nsaccf = pd.read_csv(data_dir + 'fronts/saccf.txt', header=None, sep='\\s+', \n                    na_values='%', names=['lon','lat'])\nsbdy = pd.read_csv(data_dir + 'fronts/sbdy.txt', header=None, sep='\\s+', \n                   na_values='%', names=['lon','lat'])\n\n# +\n# Plot the Saildrone track on a map\n\n# Make the \"bones\" of the figure\nplt.figure(figsize=(10, 10))\nax = plt.axes(projection=ccrs.SouthPolarStereo())\nax.set_extent([-180, 180, -90, -30],ccrs.PlateCarree())\nax.add_feature(cartopy.feature.LAND)\nax.add_feature(cartopy.feature.OCEAN, color='lightblue')\nax.gridlines()\n\n# Compute a circle in axes coordinates, which we can use as a boundary\n# for the map. We can pan/zoom as much as we like - the boundary will be\n# permanently circular.\ntheta = np.linspace(0, 2 * np.pi, 100)\ncenter, radius = [0.5, 0.5], 0.5\nverts = np.vstack([np.sin(theta), np.cos(theta)]).T\ncircle = mpath.Path(verts * radius + center)\n\n# Plot the ACC fronts in various colors\nax.set_boundary(circle, transform=ax.transAxes)\nplt.plot(stf['lon'], stf['lat'], color='Red', transform=ccrs.PlateCarree(), \n         label = 'Subtropical Front')\nplt.plot(saf['lon'], saf['lat'], color='Orange', transform=ccrs.PlateCarree(), \n         label = 'Subantarctic Front')\nplt.plot(pf['lon'], pf['lat'], color='Yellow', transform=ccrs.PlateCarree(), \n         label = 'Polar Front')\nplt.plot(saccf['lon'], saccf['lat'], color='Green', transform=ccrs.PlateCarree(), \n         label = 'Southern ACC Front')\nplt.plot(sbdy['lon'], sbdy['lat'], color='Blue', transform=ccrs.PlateCarree(), \n         label = 'Southern Boundary of ACC')\n\n# Plot the Saildrone in black dots\nplt.scatter(Saildrone_CO2.Longitude, Saildrone_CO2.Latitude,\n           transform=ccrs.PlateCarree(), c='black', s=3, label='Saildrone', zorder=1000)\n\n# Turn on the legend\nplt.legend()\n\n# Save the figure in the output folder\nplt.title('2019 Saildrone Antarctic Circumnavigation Track')\nplt.savefig(output_dir + 'SaildroneMap' + '.jpg') # Changing the suffix will change the format\nplt.show()\n\n# +\n# Now plot some variable \"var\" on the map with colored dots\nvar = 'SST (C)'\n\n# Make the \"bones\" of the figure\nplt.figure(figsize=(10, 10))\nax = plt.axes(projection=ccrs.SouthPolarStereo())\nax.set_extent([-180, 180, -90, -30],ccrs.PlateCarree())\nax.add_feature(cartopy.feature.LAND)\nax.add_feature(cartopy.feature.OCEAN, color='lightblue')\nax.gridlines()\n\n# Compute a circle in axes coordinates, which we can use as a boundary\n# for the map. We can pan/zoom as much as we like - the boundary will be\n# permanently circular.\ntheta = np.linspace(0, 2 * np.pi, 100)\ncenter, radius = [0.5, 0.5], 0.5\nverts = np.vstack([np.sin(theta), np.cos(theta)]).T\ncircle = mpath.Path(verts * radius + center)\n\n# Plot the ACC fronts in various colors\nax.set_boundary(circle, transform=ax.transAxes)\nplt.plot(stf['lon'], stf['lat'], color='Red', transform=ccrs.PlateCarree(), \n         label = 'Subtropical Front')\nplt.plot(saf['lon'], saf['lat'], color='Orange', transform=ccrs.PlateCarree(), \n         label = 'Subantarctic Front')\nplt.plot(pf['lon'], pf['lat'], color='Yellow', transform=ccrs.PlateCarree(), \n         label = 'Polar Front')\nplt.plot(saccf['lon'], saccf['lat'], color='Green', transform=ccrs.PlateCarree(), \n         label = 'Southern ACC Front')\nplt.plot(sbdy['lon'], sbdy['lat'], color='Blue', transform=ccrs.PlateCarree(), \n         label = 'Southern Boundary of ACC')\n\n# Plot the Saildrone in black dots\nplt.scatter(Saildrone_CO2.Longitude, Saildrone_CO2.Latitude, \n            c=Saildrone_CO2[var], cmap='bwr',\n            transform=ccrs.PlateCarree(), s=5, zorder=1000)\n\n# Turn on the legend\nplt.legend()\ncb1 = plt.colorbar()\n\n# Save the figure in the output folder\nplt.title('2019 Saildrone ' + var[:4])\nplt.savefig(output_dir + var[:4] + 'SaildroneMap' + '.jpg') # Changing the suffix will change the format\nplt.show()\n# -\n\n# Now let's make a map of some satellite data to show the Saildrone crossing an ocean eddy.\n#\n# First we need to load in a single daily satellite sea surface height data file from Feb 10th 2019, the day the Saildrone crossed a large eddy.\n\nsatellite_ssh = xr.open_dataset(data_dir + 'ssh_2019_02_10.nc')\n\n# Now plot the Saildrone path on a map of sea surface height for a region surrounding the Saildrone on Feb 10th\n\n#set plot parameters (contour levels, colormap etc)\nlevels_1 = np.arange(-1.2,0.8,0.1) #contour levels\ncmap_1 = 'viridis' #contour map colormap\nc1 = 'black' #Saildrone track color\n\n# +\n#finding position of Saildrone on Feb 10\ntime_index = np.where(Saildrone_CO2['Date']=='02/10/2019')\ntlon = Saildrone_CO2.Longitude.values[time_index]\ntlat = Saildrone_CO2.Latitude.values[time_index]\n\n#make a contour plot of satellite ssh\nxr.plot.contourf(satellite_ssh.adt[0,:,:],levels=levels_1,cmap=cmap_1,size=8,aspect=2)\nxr.plot.contour(satellite_ssh.adt[0,:,:],levels=levels_1,colors='k',linewidths=0.75)\nplt.xlim(tlon.min()+360-5,tlon.max()+360+5)\nplt.ylim(tlat.min()-5,tlat.max()+5)\n\n#add Saildrone track\nplt.scatter(Saildrone_CO2.Longitude+360, Saildrone_CO2.Latitude, c=c1, s=3, label='Saildrone', zorder=1000)\nplt.legend()\n\n#give the plot a title and save figure in the output folder\nplt.title('Saildrone path across an eddy on Feb 10th')\nplt.savefig(output_dir + 'Sea_surface_height_Saildrone_Feb10' + '.jpg')\n\n# -\n\n# Ocean eddies can be identified by closed rings of constant absolute dynamic topography (this is the anomaly in sea surface height from average sea level in meters, which represents changes in pressure). You can see the Saildrone's path crossing near the center of an eddy.\n#\n# We can do the same thing with satellite chlorophyll-a data. The chlorophyll-a data gives an approximate estimate of the relative phytoplankton biomass (in units of mg/m<sup>3</sup>) at the sea surface in different locations. \n\n#load satellite chl-a data file\nsatellite_chla = xr.open_dataset(data_dir + 'A20190412019048.L3m_8D_CHL_chlor_a_4km.nc')\n\n# Here you can edit parameters (colors, range etc) for the map\n\n#set plot parameters (contour levels, colormap etc)\nlevels_1 = np.arange(0,1.0,0.01) #contour levels\ncmap_1 = 'YlGnBu' #contour map colormap\nc1 = 'black' #Saildrone track color\n\n# +\n#make a contour plot of chl-a data \nsatellite_chla.chlo_a.values[satellite_chla.chlo_a>1000] = np.nan\nxr.plot.contourf(satellite_chla.chlo_a, levels = levels_1, cmap=cmap_1,size=8,aspect=2)\nplt.xlim(tlon.min()-5,tlon.max()+5)\nplt.ylim(tlat.min()-5,tlat.max()+5)\n\n#add Saildrone track\nplt.scatter(Saildrone_CO2.Longitude, Saildrone_CO2.Latitude, c=c1, s=3, label='Saildrone', zorder=1000)\nplt.legend()\n\n#save figure\nplt.title('Saildrone path and chlorophyll-a concentration')\nplt.savefig(output_dir + 'Sea_surface_chlorophylla_Saildrone_Feb10' + '.jpg')\n# -\n\n# Now we can add the Saildrone data observations on the map to start to see if there is a relationship between the satellite observations and what the Saildrone measured directly. Note that the Saildrone took a few days to cross this region, while the satellite data shown here is a snapshot for a single day, so it can be tricky to compare the two types of data because the Saildrone is moving in space AND time.\n\n#choose which variable to plot\nvar = 'SST (C)'\n#set minimum and maximum colorbar limits\nv_min = 6\nv_max = 12\n#choose colormap for map\ncmap_1 = 'viridis'\n#choose colormap for Saildrone variable\ncmap_2 = 'RdBu_r'\n\n# +\n#make a contour plot of satellite ssh\nxr.plot.contourf(satellite_ssh.adt[0,:,:],levels=np.arange(-1.2,0.8,0.1),cmap=cmap_1,size=8,aspect=2)\nxr.plot.contour(satellite_ssh.adt[0,:,:],levels=np.arange(-1.2,0.8,0.1),colors='black',linewidths=0.75)\nplt.xlim(tlon.min()+360-5,tlon.max()+360+5)\nplt.ylim(tlat.min()-5,tlat.max()+5)\n\n#add Saildrone data scattered on top\nplt.scatter(Saildrone_CO2.Longitude+360, Saildrone_CO2.Latitude, c=Saildrone_CO2[var], s=15, cmap = cmap_2,\n            vmin=v_min,vmax=v_max,label='Saildrone', zorder=1000)\nplt.legend()\nplt.colorbar()\n\n#add title and save figure\nplt.title('Saildrone ' + var[:4] + ' across an eddy on Feb 10th')\nplt.savefig(output_dir + 'Sea_surface_height_Saildrone_' + var[:4] + '_Feb10' + '.jpg')\n# -\n\n# Now that we've plotted some Saildrone and satellite data on maps to see how different ocean variables are related, there are other ways we can look at the relationship between variables. \n#\n# This includes scatter plots, which is a useful way to compare data from two variables collected at the same time and location to look for a relationship. In our case, we can compare two different variables collected simulatneously by the Saildrone. \n\n# +\n#choose two variables from the Saildrone to compare\nvar1 = 'SST (C)'\nvar2 = 'pCO2 SW (sat) uatm'\n\n#choose lower and upper limits for the two variables for plotting\nvar1_min = -2\nvar1_max = 18\n#var2_min = 98\n#var2_max = 102\n\n# +\n#create scatter plot\nplt.figure(figsize=(12,8))\nplt.scatter(Saildrone_CO2[var1], Saildrone_CO2[var2], s=10)\nplt.xlim(var1_min,var1_max)\n#plt.ylim(var2_min,var2_max)\nplt.xlabel(var1)\nplt.ylabel(var2)\nplt.grid()\n\n#add title and save figure\nplt.title('Saildrone '+ var1[:4] + ' vs ' + var2[:4])\nplt.savefig(output_dir + 'Saildrone_' + var1[:4] + '_vs_' + var2[:4] + '.jpg')\n# -\n\n# If we want to look at the relationship between more than two variables, one way we can look at this is by using a third variable to change the color of the scatter plot points.\n#\n# In this example, the scatter plot shows the same variable 1 and 2 from the Saildrone on the x and y axes as above, but we can choose a third Saildrone variable as the color of the scatter plot points.\n\n# +\n#choose a third variable \nvar3 = 'Latitude'\n\n#set lower and upper limits of variable 3 for plotting\nvar3_min = -65\nvar3_max = -40\n\n# +\n#create scatter plot\nplt.figure(figsize=(12,8))\nplt.scatter(Saildrone_CO2[var1], Saildrone_CO2[var2], c=Saildrone_CO2[var3], \n            s=10, vmin = var3_min, vmax = var3_max)\nplt.xlim(var1_min,var1_max)\n#plt.ylim(var2_min,var2_max)\nplt.xlabel(var1)\nplt.ylabel(var2)\nplt.grid()\ncbar = plt.colorbar()\ncbar.set_label(var3)\n\n#add title and save figure\nplt.title('Saildrone '+ var1[:4] + ' vs ' + var2[:4])\nplt.savefig(output_dir + 'Saildrone_' + var1[:4] + '_vs_' + var2[:4] + '_vs_' + var3[:4] + '.jpg')\n# -\n\n# Plot time series of wind speed and pressure\n\n# +\n#input plot parameters\n\n#variables to plot\nvar1 = 'WSPD (m/s)'\nvar2 = 'Licor Atm Pressure (hPa)'\n\n#set x axis limits\n\n# +\n#plot time series\nplt.figure(figsize=(12,5))\nax1 = plt.subplot(211)\nax1.plot(Saildrone_CO2.datetime,Saildrone_CO2[var1])\nplt.xlim(Saildrone_CO2.datetime.values[0],Saildrone_CO2.datetime.values[-1])\n\nax2 = plt.subplot(212)\nax2.plot(Saildrone_CO2.datetime,Saildrone_CO2[var2])\nplt.xlim(Saildrone_CO2.datetime.values[0],Saildrone_CO2.datetime.values[-1])\nplt.show()\n# -\n# Next, we can calculate the flux of carbon between the ocean and the atmosphere based on the difference in pCO2 between the atmosphere and the ocean. \n\n\n# +\n#constants for CO2 flux calculation\n#ocean/atmosphere variables needed as inputs\nT = Saildrone_CO2['SST (C)'] #sea surface temperature\nS  = Saildrone_CO2['Salinity'] #sea surface salinity\nu = Saildrone_CO2['WSPD (m/s)'] #surface wind speed\ndpCO2 = Saildrone_CO2['dpCO2'] #difference between ocean and atmosphere pCO2\n\n#1. Calculate the transfer velocity (Wanninkhof et al. 2014)\n#Schmidt number as a function of temperature \nSc = 2116.8-136.25*T  + 4.7353*np.power(T,2) - 0.092307*np.power(T,3) + 0.000755*np.power(T,4)\nK = 0.251*(u*u)*np.power((Sc/660),-0.5)\nK = K\n\n#2. calculate solubility constant as a function of temperature and salinity \nT_K = T + 273.15\nK0 = -58.0931 + ( 90.5069*(100.0 /T_K) ) \\\n    + (22.2940 * (np.log(T_K/100.0))) + (S * (0.027766 +  ( (-0.025888)*(T_K/100.0)) \\\n    + (0.0050578*( (T_K/100.0)*(T_K/100.0) ) ) ) )\na = np.exp(K0)\n\n#CO2 flux equation\nSaildrone_CO2['FCO2'] = 0.24 * K * a * dpCO2  #FCO2 = K*a(dpCO2)\n# -\n\n# Let's plot the time series of carbon fluxes together with the time series of wind speed to see how they are related. Sign of FCO2?\n\n# +\n#variables to plot\nvar1 = 'WSPD (m/s)'\nvar2 = 'FCO2'\n\n#colors\nc1 = 'darkblue'\nc2 = 'darkorange'\n\n# +\n#plot time series\nfig, ax1 = plt.subplots(figsize=(12,5))\n\n#y axis 1\nax1.plot(Saildrone_CO2['datetime'],Saildrone_CO2[var1],color=c1)\nax1.set_xlabel('date')\nax1.set_ylabel(var1, color=c1)\nax1.tick_params(axis='y', labelcolor=c1)\n\n#y axis 2\nax2 = ax1.twinx()\nax2.plot(Saildrone_CO2['datetime'],-Saildrone_CO2[var2],color=c2)\nax2.set_xlabel('date')\nax2.set_ylabel(var2, color=c2)\nax2.tick_params(axis='y', labelcolor=c2)\n\nax2.plot([Saildrone_CO2['datetime'].values[0], Saildrone_CO2['datetime'].values[-1]],[0,0],\n         color='black', linewidth=0.5)\nplt.xlim(Saildrone_CO2['datetime'][0],Saildrone_CO2['datetime'][1800])\nfig.tight_layout()\nplt.show()\n# -\n\n\n", "meta": {"hexsha": "5167caf1e1bfdedc5dde5481df3ca60c5d111f53", "size": 16611, "ext": "py", "lang": "Python", "max_stars_repo_path": "OCG_Saildrone_Lesson_Notebook.py", "max_stars_repo_name": "scottyhq/OCG_Saildrone", "max_stars_repo_head_hexsha": "f4d11a79d8c9c14bd54218ed9d2803c05c6c43ea", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "OCG_Saildrone_Lesson_Notebook.py", "max_issues_repo_name": "scottyhq/OCG_Saildrone", "max_issues_repo_head_hexsha": "f4d11a79d8c9c14bd54218ed9d2803c05c6c43ea", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "OCG_Saildrone_Lesson_Notebook.py", "max_forks_repo_name": "scottyhq/OCG_Saildrone", "max_forks_repo_head_hexsha": "f4d11a79d8c9c14bd54218ed9d2803c05c6c43ea", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.2695035461, "max_line_length": 413, "alphanum_fraction": 0.7218108482, "include": true, "reason": "import numpy", "num_tokens": 5027, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4339814648038986, "lm_q2_score": 0.12252321091611636, "lm_q1q2_score": 0.053172802545853194}}
{"text": "# -*- coding: utf-8 -*-\n\"\"\"\nHunterLab Dataset\n=================\n\nDefines the *HunterLab* illuminants dataset for the\n*CIE 1931 2 Degree Standard Observer* and\n*CIE 1964 10 Degree Standard Observer*.\n\nThe currently implemented data has been extracted from :cite:`HunterLab2008b`,\nhowever you may want to use different data according to the tables given in\n:cite:`HunterLab2008c`.\n\nSee Also\n--------\n`Illuminants Jupyter Notebook\n<http://nbviewer.jupyter.org/github/colour-science/colour-notebooks/\\\nblob/master/notebooks/colorimetry/illuminants.ipynb>`_\n\nReferences\n----------\n-   :cite:`HunterLab2008b` : HunterLab. (2008). Hunter L,a,b Color Scale.\n    Retrieved from http://www.hunterlab.se/wp-content/uploads/2012/11/\\\nHunter-L-a-b.pdf\n-   :cite:`HunterLab2008c` : HunterLab. (2008). Illuminant Factors in Universal\n    Software and EasyMatch Coatings. Retrieved from\n    https://support.hunterlab.com/hc/en-us/article_attachments/201437785/\\\nan02_02.pdf\n\"\"\"\n\nfrom __future__ import division, unicode_literals\n\nimport numpy as np\nfrom collections import namedtuple\n\nfrom colour.utilities import CaseInsensitiveMapping\n\n__author__ = 'Colour Developers'\n__copyright__ = 'Copyright (C) 2013-2019 - Colour Developers'\n__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'\n__maintainer__ = 'Colour Developers'\n__email__ = 'colour-science@googlegroups.com'\n__status__ = 'Production'\n\n__all__ = [\n    'HunterLab_Illuminant_Specification',\n    'HUNTERLAB_ILLUMINANTS_CIE_1931_2_DEGREE_STANDARD_OBSERVER_DATA',\n    'HUNTERLAB_ILLUMINANTS_CIE_1931_2_DEGREE_STANDARD_OBSERVER',\n    'HUNTERLAB_ILLUMINANTS_CIE_1964_10_DEGREE_STANDARD_OBSERVER_DATA',\n    'HUNTERLAB_ILLUMINANTS_CIE_1964_10_DEGREE_STANDARD_OBSERVER',\n    'HUNTERLAB_ILLUMINANTS'\n]\n\nHunterLab_Illuminant_Specification = namedtuple(\n    'HunterLab_Illuminant_Specification', ('name', 'XYZ_n', 'K_ab'))\n\n# yapf: disable\nHUNTERLAB_ILLUMINANTS_CIE_1931_2_DEGREE_STANDARD_OBSERVER_DATA = (\n    ('A', np.array([109.83, 100.00, 35.55]), np.array([185.20, 38.40])),\n    ('C', np.array([98.04, 100.00, 118.11]), np.array([175.00, 70.00])),\n    ('D50', np.array([96.38, 100.00, 82.45]), np.array([173.51, 58.48])),\n    ('D60', np.array([95.23, 100.00, 100.86]), np.array([172.47, 64.72])),\n    ('D65', np.array([95.02, 100.00, 108.82]), np.array([172.30, 67.20])),\n    ('D75', np.array([94.96, 100.00, 122.53]), np.array([172.22, 71.30])),\n    ('FL2', np.array([98.09, 100.00, 67.53]), np.array([175.00, 52.90])),\n    ('TL 4', np.array([101.40, 100.00, 65.90]), np.array([178.00, 52.30])),\n    ('UL 3000', np.array([107.99, 100.00, 33.91]), np.array([183.70, 37.50])))\n# yapf: enable\n\nHUNTERLAB_ILLUMINANTS_CIE_1931_2_DEGREE_STANDARD_OBSERVER = (\n    CaseInsensitiveMapping({\n        x[0]: HunterLab_Illuminant_Specification(*x)\n        for x in HUNTERLAB_ILLUMINANTS_CIE_1931_2_DEGREE_STANDARD_OBSERVER_DATA\n    }))\n\"\"\"\n*Hunter L,a,b* illuminant dataset for *CIE 1931 2 Degree Standard Observer*.\n\nReferences\n----------\n:cite:`HunterLab2008b`, :cite:`HunterLab2008c`\n\nHUNTERLAB_ILLUMINANTS_CIE_1931_2_DEGREE_STANDARD_OBSERVER :\n    CaseInsensitiveMapping\n\"\"\"\n\n# yapf: disable\nHUNTERLAB_ILLUMINANTS_CIE_1964_10_DEGREE_STANDARD_OBSERVER_DATA = (\n    ('A', np.array([111.16, 100.00, 35.19]), np.array([186.30, 38.20])),\n    ('C', np.array([97.30, 100.00, 116.14]), np.array([174.30, 69.40])),\n    ('D50', np.array([96.72, 100.00, 81.45]), np.array([173.82, 58.13])),\n    ('D60', np.array([95.21, 100.00, 99.60]), np.array([172.45, 64.28])),\n    ('D65', np.array([94.83, 100.00, 107.38]), np.array([172.10, 66.70])),\n    ('D75', np.array([94.45, 100.00, 120.70]), np.array([171.76, 70.76])),\n    ('FL2', np.array([102.13, 100.00, 69.37]), np.array([178.60, 53.60])),\n    ('TL 4', np.array([103.82, 100.00, 66.90]), np.array([180.10, 52.70])),\n    ('UL 3000', np.array([111.12, 100.00, 35.21]), np.array([186.30, 38.20])))\n# yapf: enable\n\nHUNTERLAB_ILLUMINANTS_CIE_1964_10_DEGREE_STANDARD_OBSERVER = (\n    CaseInsensitiveMapping({\n        x[0]: HunterLab_Illuminant_Specification(*x)\n        for x in\n        HUNTERLAB_ILLUMINANTS_CIE_1964_10_DEGREE_STANDARD_OBSERVER_DATA\n    }))\n\"\"\"\n*Hunter L,a,b* illuminant dataset for *CIE 1964 10 Degree Standard Observer*.\n\nReferences\n----------\n:cite:`HunterLab2008b`, :cite:`HunterLab2008c`\n\nHUNTERLAB_ILLUMINANTS_CIE_1964_10_DEGREE_STANDARD_OBSERVER :\n    CaseInsensitiveMapping\n\"\"\"\n\nHUNTERLAB_ILLUMINANTS = CaseInsensitiveMapping({\n    'CIE 1931 2 Degree Standard Observer':\n        HUNTERLAB_ILLUMINANTS_CIE_1931_2_DEGREE_STANDARD_OBSERVER,\n    'CIE 1964 10 Degree Standard Observer':\n        HUNTERLAB_ILLUMINANTS_CIE_1964_10_DEGREE_STANDARD_OBSERVER\n})\nHUNTERLAB_ILLUMINANTS.__doc__ = \"\"\"\nAggregated *Hunter L,a,b* illuminant dataset.\n\nReferences\n----------\n:cite:`HunterLab2008b`, :cite:`HunterLab2008c`\n\nHUNTERLAB_ILLUMINANTS : CaseInsensitiveMapping\n    **{'CIE 1931 2 Degree Standard Observer',\n    'CIE 1964 10 Degree Standard Observer'}**\n\nAliases:\n\n-   'cie_2_1931': 'CIE 1931 2 Degree Standard Observer'\n-   'cie_10_1964': 'CIE 1964 10 Degree Standard Observer'\n\"\"\"\nHUNTERLAB_ILLUMINANTS['cie_2_1931'] = (\n    HUNTERLAB_ILLUMINANTS['CIE 1931 2 Degree Standard Observer'])\nHUNTERLAB_ILLUMINANTS['cie_10_1964'] = (\n    HUNTERLAB_ILLUMINANTS['CIE 1964 10 Degree Standard Observer'])\n", "meta": {"hexsha": "1caea1ec4651e05a1714d28deac5f2ed6dea77e3", "size": 5301, "ext": "py", "lang": "Python", "max_stars_repo_path": "colour/colorimetry/dataset/illuminants/hunterlab.py", "max_stars_repo_name": "sobotka/colour", "max_stars_repo_head_hexsha": "aa3fe95fba83ffc0f3ce1eb6aca85e6d8f3bde51", "max_stars_repo_licenses": ["Cube", "BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-05-03T20:15:42.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-09T18:19:06.000Z", "max_issues_repo_path": "colour/colorimetry/dataset/illuminants/hunterlab.py", "max_issues_repo_name": "sobotka/colour", "max_issues_repo_head_hexsha": "aa3fe95fba83ffc0f3ce1eb6aca85e6d8f3bde51", "max_issues_repo_licenses": ["Cube", "BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "colour/colorimetry/dataset/illuminants/hunterlab.py", "max_forks_repo_name": "sobotka/colour", "max_forks_repo_head_hexsha": "aa3fe95fba83ffc0f3ce1eb6aca85e6d8f3bde51", "max_forks_repo_licenses": ["Cube", "BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.3309859155, "max_line_length": 79, "alphanum_fraction": 0.710431994, "include": true, "reason": "import numpy", "num_tokens": 1810, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48438008427698437, "lm_q2_score": 0.10970578115498412, "lm_q1q2_score": 0.05313929552152361}}
{"text": "# Manipulating Time-series\n\nTime-series are a key element when assessing solar resource data. In this section, we present several examples to learn how to deal with different formats in the data and few common tasks to prepare our time-series for later analysis, such as down and up-sampling data when we need different temporal resolution than that initially available or interpolating missing values in the data. \n\nThe dataset used in the examples of this section is a customized dataset using solar radiation measurements from the Measurement and Instrumentation Data Center (MIDC) of the U.S. National Renewable Energy Laboratory (NREL). The station selected is located at the University of Nevada - Las Vegas (UNLV) and the data used are 1-minute GHI, DHI and DNI measurements for the year 2020 (Andreas and Stoffel, 2006).\n\nIn this section, we cover: <br>\n- [1 Time-series handling](#timeseries_handling) <br>\n- [2 Down and up-sampling time-series data](#timeseries_downup_sampling) <br>\n- [3 Interpolating time-series data](#timeseries_interpolation) <br>\n- [4 Visualizating time-series data](#timeseries_visualization)\n\n\n***\n\n## 1 Time-series handling <a id='timeseries_handling'></a>\nDatasets often come in different formats depending on the source. Those formats sometimes cannot be used straightaway to build a time-series and may require additional processing steps before building the time-series. For example:  <br>\n- **What if date and time are in different columns?** <br> \n- **What if the year, month, day and time are in separate columns?** <br>\n- **How to the define the timestamp format for a particular dataset?** <br>\n- **How to deal with timestamp issues, local vs. universal (UTC) time?**\n\nThis subsection presents several examples to deal with different formats in which time-series data could come and shows how to build a time-series or *datetime series*, as known in Python, for later analysis. The processing steps to build time-series are based on [pandas library](https://pandas.pydata.org/).\n\nLet's get started!\n\n# Importing the needed libraries\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport pvlib\n\n### 1.1 Build our customized dataset\nIn order to build the customized dataset for this section, we make use of the I/O tools of the Python library *pvlib* to retrieve the data from the UNLV station in the MIDC. Data from other stations from the MIDC can be also retrieved using this method by adapting the station ID in the query. The different station IDs are available in the [MIDC raw data page](https://midcdmz.nrel.gov/apps/data_api_doc.pl?_idtextlist).\n\n# Dictionary to rename certain variables from the raw data\nvar_map = {'Global Horiz [W/m^2]': 'ghi',\n           'Direct Normal [W/m^2]':'dni',\n           'Diffuse Horiz (calc) [W/m^2]':'dhi',\n           'Year':'year'}\n\n# Retrieving the raw data from the station \ndf_ref = pvlib.iotools.read_midc_raw_data_from_nrel('UNLV',                     # Station id\n                                                    pd.Timestamp('20200101'),   # Start date YYYYMMDD\n                                                    pd.Timestamp('20201231'),   # End date  YYYYMMDD\n                                                    variable_map=var_map)       # Variable Map\n# Let's have a look to the first 2 rows of the dataset\ndf_ref.head(2)\n\n# Let's have a look to the last 2 rows of the dataset\ndf_ref.tail(2)\n\nThe dataset is 1-minute resolution data with 21 variables related to meteorological and other relevant data: ambient temperature, wind speed, wind direction, global horizontal irradiance (GHI), direct normal irradiance (DNI), diffuse horizontal irradiance (DHI), zenith and azimuth angles, airmass, among other. \n\nFor the examples in this section we will use GHI, DNI and DHI measurements and time-related data.\n\n# Slice desired variables out of the 21 variables provided in the raw data. \ndf_ref = df_ref[['ghi', 'dni', 'dhi', 'year']]\n\n# Add multiple temporal data to the dataset\ndf_ref['month'] = df_ref.index.month\ndf_ref['day'] = df_ref.index.day\ndf_ref['hour'] = df_ref.index.hour\ndf_ref['minute'] = df_ref.index.minute\ndf_ref['date'] = df_ref.index.strftime('%Y-%m-%d')\ndf_ref['time'] = df_ref.index.strftime('%H:%M:%S')\ndf_ref['timestamp'] = df_ref.index.strftime('%Y-%m-%d %H:%M:%S%z')\n\n# Epoch format\ndf_ref['epoch'] = df_ref.index.astype('int64')//1e9\n\n# Reset the Index of the DataFrame\ndf_ref = df_ref.reset_index(drop=True)\n\n# Let's have a look to the resulting columns of the dataset\ndf_ref.columns\n\nLet's visualize the first rows of the **customized reference dataframe:**\n\n# First 3 rows in the dataframe\ndf_ref.head(3)\n\nNow that we have our customized reference dataset of 1-minute irradiance measurements for 2020 and temporal data, we can start building the timeseries in different ways.\n\n### 1.2 Time-series when timestamps are available:\n\nWhen timestamps are available, the most straightforward way to build the DataFrame with a datetime index is to convert the column with the timestamp into datetime format and set it as index.\n\nLet's see how!\n\n# A new dataframe copy of the reference dataset\ndf = df_ref.copy()\n# Convert the timestamp string into datetime format \ndf['timestamp'] = pd.to_datetime(df['timestamp'], format='%Y-%m-%d %H:%M:%S%z')\n# Set timestamp column as index\ndf = df.set_index(df['timestamp'])\n# See the first 3 rows of the DataFrame with Datetime Index\ndf.head(3)\n\nThe format of the timestamp is specified in the argument 'format' as a string and can be adapted to any case. The available options in Python can be checked in this [link](https://strftime.org/). \n\nUniversal Time Coordinated (UTC) is usually the timestamp provided for many solar radiation data networks and platforms like the BSRN, PVGIS, etc. However, data can be also reported in local time like in our example. Timestamps can be converted to other timezones with the funcion *tz_convert*, which can be useful when dealing with data from different databases and locations worldwide:\n\n# Add UTC timestamp from the local time (Pacific Summer Time)\ndf['timestamp_utc'] = df.index.tz_convert('UTC')\n# See the first 3 rows \ndf.head(3)\n\nThe valid timezone strings for other timezones can be found in this [link](https://pvlib-python.readthedocs.io/en/stable/timetimezones.html). When the timezone is not provided as part of the timestamp, the function *tz_localize* can be used to localize the values in a timezone-naive series. *tz_localize* will be used in the next example.\n\n### 1.3 Time-series when date and time are available:\n\nWhen date and time are available in separate columns, a timestamp can be created in a new column and the new column can then be set as index and localized. Let's have a look how to do that:\n\n\n# A new dataframe copy of the reference dataset\ndf = df_ref.copy()\n# New column with the date and time \ndf['datetime'] = df['date'] + 'T' + df['time']\n# Convert the new column into datetime format \ndf['datetime'] = pd.to_datetime(df['datetime'], format='%Y-%m-%dT%H:%M:%S')\n# Set the column 'datetime' as index and localize it to its timezone\ndf = df.set_index(df['datetime']).tz_localize('Etc/GMT+8')\n# See the first 3 rows \ndf.head(3)\n\n### 1.4 Time-series when the time data is split in multiple columns:\n\nIf time-related data are split across multiple columns, a timestamp can be created in a new column similarly than in the previous case. Let's imagine our dataset would have the year, month, day, hour, and minute in separate columns. In that case, we could build our time-series as follows:\n\n# A new dataframe copy of the reference dataset\ndf = df_ref.copy()\n# Let's reduce the code lines and define the new string within the 'to_datetime' function\ndf['datetime'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], \n                                format = '%Y-%m-%d%H:%M')\n# Set the column 'datetime' as index\ndf = df.set_index(df['datetime']) \n# Localize the datetime series\ndf.index = df.index.tz_localize('Etc/GMT+8') \n# See the first 3 rows \ndf.head(3)\n\n### 1.5 Time-series when the timestamp is given as epoch (Unix Time)\n\nIf the dataset has epoch timestamps, note that the data will have UTC time. However, it can be converted to any timezone using the function *tz_convert*. If there are epoch timestamps, a datetime series can be formed as follows:\n\n# A new dataframe copy of the reference dataset\ndf = df_ref.copy()\n# Convert epoch timestamps to datetime format and localize\ndf['datetime'] = pd.to_datetime(df['epoch'], unit='s', utc=True)\n# Set datetime as index and convert UTC time to local time\ndf = df.set_index(df['datetime']).tz_convert('Etc/GMT+8')\n# See the results\ndf.head(3)\n\nWe have seen how the same DataFrame with *datetimeindex* can be obtained in multiple ways depending on the format of time data provided.\n\n***\n\n## 2 Down and up-sampling time-series data<a id='timeseries_downup_sampling'></a>\n\nWhen assessing solar resource, you may need a different time-resolution than your data for a particular part of the analysis. In those cases, it is possible to **down-sample and up-sample the data at different temporal resolutions** using two different methods within [pandas library](https://pandas.pydata.org/) called *resample* and *asfreq*. Depending on your needs, you will opt for one or the other. Regardless of the method, both of them require a DataFrame with *datetimeindex* either time-aware (localized) or time-naive (not localized). \n\n###  2.1 Method 'asfreq' vs. 'resample'\nLet's first create a new DataFrame with only the columns with solar data and see the differences between both methods with examples.\n\n# New DataFrame with 1-minute data and solar data\ndf_1min = df[['ghi', 'dhi', 'dni']]\n# See our new DataFrame\ndf_1min.head(3)\n\nLet's try to obtain a DataFrame down-sampled with the maximum monthly data with both methods and see the differences. With *asfreq*, it would be the following:\n\ndf_1min.asfreq(\"1M\").max()\n\nWith *resample* the result would be:\n\ndf_1min.resample(\"1M\").max()\n\nIt is obvious that the outputs are not the same and that is because the methods work differently. *asfreq* takes the value at the simultaneous stamps given by the frequency argument. See below:\n\ndf_1min.asfreq(\"1M\")\n\nThen *.max()* has returned the maximum of each of the columns. \n\nIn contrast, *resample* does return the maximum value within the period of time at the specified frequency. *resample* method requires a mathematical operation to perform in the resampled data (the maximum value in our case). Otherwise, it would return a *DatetimeIndexResampler* object without showing any data. See below:\n\ndf_1min.resample(\"1M\")\n\nThe *resample* method accepts multiple **mathematical and statistical operations**. For example: maximum (max), minimum (min), arithmetic mean (mean), standard deviation (std), median (median), mode (mode), addition (sum), among others. \n\nBoth methods allow for multiple **frequencies options**, the available frequency tags within Python can be found [here](https://stackoverflow.com/questions/35339139/where-is-the-documentation-on-pandas-freq-tags).\n\n### 2.2 Down-sampling the data in a time-series\n\nDown-sampling permits turning more frequent values into less frequent. In the context of solar resource and considering our 1-minute resolution dataset, down-sampling can be used for:\n- Producing a timeseries of hourly/daily average irradiance.\n- Producing a timeseries of maximum daily irradiance.\n- Estimating the hourly/daily/monthly sums of irradiation.\n- And many more!\n\nLet's implement some of these listed examples!\n\n#### Producing hourly average irradiance from minutely observations\n\n# Resampling to hourly mean values\ndf_hourly = df_1min.resample(\"1H\").mean()\n# Showing the shape of the new DataFrame\ndf_hourly.shape # returns Rows, Columns\n\nThere are 8760 hours in a year. Yet, we can have a look to the first few rows of the DataFrame:\n\ndf_hourly.head(12)\n\nA time-series with the maximum irradiance would be similar replacing *'mean()'* with *'max()'*.\n\n#### Producing time-series of monthly total GHI, DHI, DNI irradiation from minutely observations\n\n# Resampling to monthly aggregated values\nmonthly_energy = df_1min[['ghi', 'dhi', 'dni']].resample(\"1M\").sum()*(1/60)\n# See the results expressed in kWh·sqm\nmonthly_energy/1000\n\nIt could be done in similar way for other resolutions (e.g. daily or annual irradiation).\n\n### 2.3 Up-sampling the data in a time-series\n\nUp-sampling permits obtaining more frequent values from less frequent. For solar data, depending on the application up to sub-minutely data could be required and up-sampling is a technique that provides a manner to increase the temporal resolution to adapt it to our needs. For example, turning an hourly time-series into a half-hourly. Let's see an example using both *resample* and *asfreq*.\n\n#### Producing half-hourly irradiance series from hourly observations\nUsing the DataFrame *df_hourly* created previously, it can be up-sample as follows:\n\n# Using 'resample' method:\ndf_hourly.resample(\"30Min\").mean().head(10)\n\n# Using 'asfreq' method:\ndf_hourly.asfreq(\"30Min\").head(10)\n\nContrary to the case of down-sampling, both *asfreq* and *resample* provide similar results when up-sampling. However, *asfreq* provides additional functionalities to treat the new timestamps without data, i.e. NaN values.\n\nBy passing the argument *'method'* with the string *'backfill'* or *'bfill'* uses the next valid observation to fill the NaN value (back filling). If instead, the string *'pad'* or *'ffill'* is given, the method assigns the last valid observation forward to the next valid (forward filling). \n\nLet's see the same example adding this argument:\n\n# Half-hourly up-sample with back filling function\ndf_hourly.asfreq(\"30Min\", method='bfill').head(10)\n\nWe see that the DataFrame now contains the next valid hourly value in the newly obtained half-hourly timestamps of the previous hour. It would take the previous valid hourly value if we used forward filling. For example:\n\n# Half-hourly up-sample with forward-filling function\ndf_hourly.asfreq(\"30Min\", method='ffill').head(10)\n\nThe forward filling option provides the same value for o'clock and half past timestamps within the same hour. In addition to these two ways to complete the NaN values, the method *asfreq* can replace the NaN values with a constant. See below:\n\n# Half-hourly up-sample filling the new timestamps with a constant\ndf_hourly.asfreq(\"30Min\", fill_value=0).head(10)\n\nThe use of the methods *asfreq* or *resample* will depend on your dataset and the analysis you aim to undertake.\n\n***\n\n## 3 Interpolating time-series data<a id='timeseries_interpolation'></a>\n\nWhen up-sampling the data series, it can happen that back-filling, forward-filling and constant replacement does not necessarily work for your analysis/application. An alternative approach is interpolating the replacing the NaN values with an interpolated result. Interpolation in Pandas DataFrames with *DatetimeIndex* is done with the *interpolate* method.\n\nThe mathematical interpolation method in *interpolate* is defined with the argument called *'method'*. Pandas permits several interpolation methods, such as 'linear', 'cubic', 'quadratic', 'spline', 'polynomial' and others. All the interpolation options can be found in the [documentation](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.interpolate.html) of the *interpolate* method. \n\nFollowing the previous example, let's implement interpolation in the missing values of the half-hourly timestamps using 'linear', 'cubic' and 'polynomial' methods:\n\n# Up-sample using the 'asfreq' method\ndf_30min = df_hourly.asfreq(\"30Min\")\n# Interpolate missing values (NaN) with linear interpolation\ndf_linear = df_30min.interpolate(method='linear')\n# See the results:\ndf_linear.head(10)\n\nSimilarly, it can be implemented to other methods:\n\n# Interpolate missing values (NaN) with cubic interpolation\ndf_cubic = df_30min.interpolate(method='cubic')\n# See the results:\ndf_cubic.head(10)\n\nWith polynomial interpolation, the degree or order of the polynomial function needs to be defined as an argument:\n\n# Interpolate missing values (NaN) with polynomial interpolation\ndf_polynomial = df_30min.interpolate(method='polynomial', order=5)\n# See the results:\ndf_polynomial.head(10)\n\nThe interpolation of NaN values when up-sampling time-series data can help overcome the issues of using back or forward filling, specially if you aim to up-sample at higher frequencies than the example shown (e.g. 1-hour to 15-minute resolution series). The mathematical methods available for interpolation within Pandas are diverse and cover beyond the most common interpolation functions.\n\n## 4 Visualizing time-series data<a id='timeseries_visualization'></a>\n\nIt is often useful to visualize the data to grasp insighs and observe trends about the data. This section shows few examples to visualize time-series data.\n\n### 4.1 Plotting a time-series for a day of interest\n\nBelow there is an example to visualize a single day of interest. With DataFrames using *DatetimeIndex* it is easy to select a particular day and Pandas interacts with Matplotlib.Pyplot library to plot straight-away.\n\n# Plotting GHI for a given day in the time-series\ndf_1min['2020-06-01']['ghi'].plot(label='GHI')\nplt.ylabel('Irradiance [W/m$^2$]')\nplt.xlabel('Local Time [HH:MM]')\nplt.legend(loc='best')\nplt.show() # Not needed in Jupyter Notebooks but usually required in other IDEs.\n\nWe can visualize the effect of using average (*resample*) vs. instantaneous (*asfreq*) measurements when down-sampling our data.\n\n# Plotting GHI for a given day in the time-series\ndf_1min['2020-06-01']['ghi'].plot(label='1-min data', alpha=0.4) # Reference data\ndf_1min.asfreq('30Min')['2020-06-01']['ghi'].plot(label='30-min instant.') # Instantaneous 30-min values\ndf_1min.resample('30Min').mean()['2020-06-01']['ghi'].plot(label='30-min average') # Average 30-min values\nplt.title('Average vs. Actual GHI Measurements') # title of the figure\nplt.ylabel('Irradiance [W/m$^2$]') # y-axis label\nplt.xlabel('Local Time [HH:MM]') # x-axis label\nplt.legend(loc='upper left') # insert legend\nplt.show() # Not needed in Jupyter Notebook but usually required in other IDEs.\n\n### 4.2 Plotting a time-series for a few consecutive days of interest\n\nBelow there is an example to visualize a few consecutive days (e.g. 5 days) of interest. By using ['start date']:['end date'] it is possible to select time ranges easily with a DataFrame having a *DatetimeIndex*.\n\n# Variables to plot\nvars = ['ghi', 'dni', 'dhi'] \n# Create 3 subplots, with shared X and Y axis\nfig, axs = plt.subplots(3, sharex=True, sharey=True, figsize=(9,6))\n# Add title to the plot\nfig.suptitle('Average Hourly Solar Radiation Observations', fontsize=14)\n\nfor i in range(3):\n    axs[i].plot(df_1min.resample('1H').mean()['2020-06-01':'2020-06-05'][vars[i]], label='Average') # Average hourly\n    axs[i].plot(df_1min.resample('1H').max()['2020-06-01':'2020-06-05'][vars[i]], label='Maximum') # Max. hourly\n    axs[i].plot(df_1min.resample('1H').min()['2020-06-01':'2020-06-05'][vars[i]], label='Minimum') # Min. hourly\n    axs[i].set_title(vars[i].upper()) # Title for each subplot\nfig.subplots_adjust(hspace=0.3) # Adjust the white space between the subplots titles\nfig.text(0.04, 0.5, 'Irradiance [W/m$^2$]', va='center', rotation='vertical', fontsize=12) # Common Y Axis\nfig.text(0.51, 0.04, 'Local Time', ha='center', fontsize=12) # Common X Axis\nplt.legend(loc='upper center', ncol=3) # Legend for the last subplot or 'axs[i].legend()' in the loop to a legend to each.\nplt.show()\n\n### 4.3 Plotting a time-series for a few non-consecutive days of interest\n\nBelow there is an example to visualize a few non-consecutive days of interest, which could be the case when we would like to observe several days scattered throughout the year a single plot. In order to do this, we need to select the day of interest from the DataFrame and then reset its *DatetimeIndex*. For example:\n\n# List of days of interest\ndays = ['2020-01-01', '2020-03-01', '2020-06-01', '2020-09-01']\n# Iterate over the days and plot each of them\nfor day in days: \n    df_day = df_1min.resample('1H').mean()[day]['ghi'].to_frame()  # average hourly of GHI for current day\n    df_day = df_day.reset_index(drop=True) # reset its Index to numeric (i.e. 0,1,2,3...)\n    plt.plot(df_day, label=day) # plot the current day\nplt.title('Average Hourly GHI Measurements for Days of Interest') # title of the figure\nplt.xticks(np.arange(0, 25, step=3), np.arange(0, 25, step=3)) # set labels positions and names\nplt.ylabel('Irradiance [W/m$^2$]') # y-axis label\nplt.xlabel('Local Time') # x-axis label\nplt.legend(loc='best') # insert legend\nplt.show()\n\n### 4.4 Daily insolation throughout the year\n\nWith time-series data, the hourly/daily/monthly insolation (i.e. the sum of accumulated energy) can also be analysed throughout the year with time-series data. For example, below an example to visualize the daily insolation is shown:\n\n# Calculate the daily insolation expressed in kWh·sqm from GHI measurements\ndaily_energy = (df_1min['ghi'].resample(\"1D\").sum()*(1/60))/1000 # selecting only GHI returns a Pandas Series\n\n# Create time-series plot\ndaily_energy.plot(figsize=(9,6), legend=False) # plot timeseries \nplt.title('Time-series of Daily Insolation')  # add title\nplt.ylabel('Energy [kWh/m$^2$]') # add Y-axis label\nplt.xlabel('Time') # add X-axis label\nplt.show()\n\nTime-series data can also be visualized in other ways, for instance, as a heat map.\n\n# Prepare the data for heat map of hourly insolation\nenergy_array = pd.DataFrame() # empty DataFrame for the results\nfor i in range(1,13): # iterate over months\n    # select the data in the month and eliminate the datetimeindex\n    df_month = daily_energy[daily_energy.index.month==i].reset_index(drop=True) \n    # rename the column with the number of the month\n    df_month.columns = [str(i)]\n    # Append results to the DataFrame\n    energy_array = pd.concat([energy_array, df_month], axis=1)\n# Transpose to have months in y-axis and days in x-axis\nenergy_array = energy_array.transpose()\n# Rename the columns of the days \nenergy_array.columns = np.arange(1, 32)\n\n# Plot heat map of daily insolation\nmonths = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', # month labels\n          'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']\nplt.figure(figsize=(10, 5))\nax = sns.heatmap(energy_array, cmap='CMRmap', linewidths=0.2, # plot heatmap with Seaborn (sns) library \n                xticklabels=2, annot=False,\n                cbar_kws={'label': 'Daily Energy [kWh/m$^2$]'})\nax.set_title('Heat Map of Daily Insolation') # add title\nax.set_yticklabels(months,rotation=0) # add the months as tick-labels for the y-axis\nax.set_xticklabels(ax.get_xticklabels(),rotation=0) # add the days as tick-labels for the x-axis\nax.set_xlabel('Day of the Month')\nplt.show()\n\n***\n\n## Section summary\n\nThis section has shown how to build and work with a time-series in Python with multiple examples: <br>\n- We have seen how to prepare a DataFrame with *DatatimeIndex* to be used as a time-series when the timestamps are given in multiple formats in the temporal data and local/UTC time. <br>\n- Changes in the temporal resolution of the data can be applied by down and up-sampling the data and the differences between 2 available methods (*asfreq* and *resample*) have been shown with examples and different sampling frequencies. <br> \n- The interpolation of missing data in time-series can be used to up-sample the resolution of the data and examples with some methods have been shown. <br>\n- Finally, several ideas to visualize data have been presented. <br>\n\nOverall, the possibilities with time-series of solar resource are many. The most useful and suitable analysis and visualizations will be determined by the application and scope of the study.\n\n***\n\n## References<a id='references'></a>\n\nAndreas, A.; Stoffel, T.; (2006). University of Nevada (UNLV):\nLas Vegas, Nevada (Data); NREL Report No. DA-5500-56509.\nhttp://dx.doi.org/10.5439/1052548\n", "meta": {"hexsha": "e0e3497abc11e3e84281d663a0f08b82a984346b", "size": 24081, "ext": "py", "lang": "Python", "max_stars_repo_path": "content/_build/jupyter_execute/notebooks/manipulating_time_series.py", "max_stars_repo_name": "AssessingSolar/Solar-Resource-Assessment-in-Python", "max_stars_repo_head_hexsha": "230558004b0cabd17d52198fd1901fe36663a036", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-03-17T15:21:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-25T07:27:24.000Z", "max_issues_repo_path": "content/_build/jupyter_execute/notebooks/manipulating_time_series.py", "max_issues_repo_name": "AssessingSolar/Solar-Resource-Assessment-in-Python", "max_issues_repo_head_hexsha": "230558004b0cabd17d52198fd1901fe36663a036", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-07-23T17:55:22.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-03T15:23:37.000Z", "max_forks_repo_path": "content/_build/jupyter_execute/notebooks/manipulating_time_series.py", "max_forks_repo_name": "AssessingSolar/Solar-Resource-Assessment-in-Python", "max_forks_repo_head_hexsha": "230558004b0cabd17d52198fd1901fe36663a036", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 56.9290780142, "max_line_length": 546, "alphanum_fraction": 0.7479755824, "include": true, "reason": "import numpy", "num_tokens": 5937, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4843800842769844, "lm_q2_score": 0.10970576951176295, "lm_q1q2_score": 0.05313928988177916}}
{"text": "# ---\n# jupyter:\n#   jupytext:\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.4'\n#       jupytext_version: 1.2.4\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# + {\"deletable\": true, \"editable\": true, \"cell_type\": \"markdown\"}\n# <div style='background-image: url(\"../../share/images/header.svg\") ; padding: 0px ; background-size: cover ; border-radius: 5px ; height: 250px'>\n#     <div style=\"float: right ; margin: 50px ; padding: 20px ; background: rgba(255 , 255 , 255 , 0.7) ; width: 50% ; height: 150px\">\n#         <div style=\"position: relative ; top: 50% ; transform: translatey(-50%)\">\n#             <div style=\"font-size: xx-large ; font-weight: 900 ; color: rgba(0 , 0 , 0 , 0.8) ; line-height: 100%\">Computational Seismology</div>\n#             <div style=\"font-size: large ; padding-top: 20px ; color: rgba(0 , 0 , 0 , 0.5)\">Reproducible Papers - Syngine Paper</div>\n#         </div>\n#     </div>\n# </div>\n\n# + {\"deletable\": true, \"editable\": true, \"cell_type\": \"markdown\"}\n# ---\n#\n# # Figure 6:  Data Quality - Detecting Wrong Times with Synthetics\n#\n# This notebook is part of the supplementary materials for the Syngine paper and reproduces figure 6.\n#\n# This notebook creates the phase relative times figure. Requires matplotlib >= 1.5 and an ObsPy version (>= 1.0) with the syngine client as well as instaseis.\n#\n# ##### Authors:\n# * Lion Krischer ([@krischer](https://github.com/krischer))\n\n# + {\"deletable\": true, \"editable\": true}\n# %matplotlib inline\n\n# + {\"deletable\": true, \"editable\": true}\nimport obspy\nimport numpy as np\nfrom obspy.clients.fdsn import Client\nfrom obspy.clients.syngine import Client as SyngineClient\n\nimport itertools\n\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.basemap import Basemap\nplt.style.use(\"seaborn-paper\")\n\n# + {\"deletable\": true, \"editable\": true}\nc_iris = Client(\"IRIS\")\n\n# + {\"deletable\": true, \"editable\": true}\n# Get all stations from the Caltech Regional Seismic Network activate\n# at the given time.\ninv = c_iris.get_stations(level=\"response\", format=\"xml\", channel=\"BHZ\",\n                          network=\"CI\", location=\"  \",\n                          startbefore=obspy.UTCDateTime(2012, 1, 1),\n                          endafter=obspy.UTCDateTime(2016, 1, 1))\ninv.plot(projection=\"local\");\nprint(inv)\n\n# + {\"deletable\": true, \"editable\": true}\n# Downloaded from the GCMT page.\n# cat = obspy.read_events(\"./cmtsolutions.txt\", format=\"CMTSOLUTION\").filter(\"latitude > -20\", \"longitude > 165\")\n\n# This is a prototype - we thus are very selective regarding which data we use...\ntraining = [\"smi:local/cmtsolution/201510202152A/event\",\n            \"smi:local/cmtsolution/201212212228A/event\",\n            \"smi:local/cmtsolution/201203090709A/event\"]\nvalidate = \"smi:local/cmtsolution/201401011603A/event\"\napplication = \"smi:local/cmtsolution/201501230347A/event\"\n\nall_data = []\nall_data.extend(training)\nall_data.append(validate)\nall_data.append(application)\n\ncat.events = [_i for _i in cat.events if _i.resource_id.id in all_data]\n\nprint(cat)\ncat.plot();\n\n# + {\"deletable\": true, \"editable\": true}\n# For all of them: download the syngine data 50 seconds before the p-phase\n# and 50 seconds after for the 5s ak135f DB.\nc_syngine = SyngineClient()\n\n# + {\"deletable\": true, \"editable\": true}\n# Download all syngine data.\nsynthetic_data = {}\n\n# Build up bulk request.\nbulk = [\n    {\"networkcode\": \"CI\", \"stationcode\": _i.code,\n     \"latitude\": _i.latitude, \"longitude\": _i.longitude} for _i in inv[0]]\n\n# Actually download everything.\nfor _i, event in enumerate(cat):\n    origin = [_i for _i in event.origins if _i.origin_type == \"hypocenter\"][0]\n    mt = event.focal_mechanisms[0].moment_tensor.tensor\n    print(\"Downloading data for event %i of %i ...\" % (_i + 1, len(cat)))\n    st_syn = c_syngine.get_waveforms_bulk(\n        model=\"ak135f_5s\", bulk=bulk, sourcelatitude=origin.latitude,\n        sourcelongitude=origin.longitude, sourcedepthinmeters=origin.depth,\n        sourcemomenttensor=[mt.m_rr, mt.m_tt, mt.m_pp, mt.m_rt, mt.m_rp, mt.m_tp],\n        origintime=origin.time,\n        components=\"Z\",\n        # Avoid downsampling - just upsample to the data sampling rate.\n        dt=1.0 / 40.0,\n        kernelwidth=10,\n        units=\"velocity\",\n        starttime=\"P-50\", endtime=\"P+50\")\n\n    this_event = {\"event_object\": event, \"stream\": st_syn}\n    synthetic_data[event.resource_id] = this_event\n    print(\"  -> Downloaded %i synthetic traces.\" % len(st_syn))\n\n# + {\"deletable\": true, \"editable\": true}\n# Reordering ... I don't want to redownload again...\ndata = synthetic_data\nfor value in data.values():\n    value[\"synthetic_stream\"] = value[\"stream\"]\n    del value[\"stream\"]\n\n# + {\"deletable\": true, \"editable\": true}\n# Now download all real data.\nfor _i, value in enumerate(data.values()):\n    print(\"Downloading data for event %i of %i ...\" % (_i + 1, len(cat)))\n    st_obs = c_iris.get_waveforms_bulk(\n        [(tr.stats.network, tr.stats.station, \"\",\n          \"BHZ\", tr.stats.starttime, tr.stats.endtime) for tr in value[\"synthetic_stream\"]])\n    value[\"observed_stream\"] = st_obs\n    print(\"  -> Downloaded %i observed traces.\" % len(st_obs))\n\n# + {\"deletable\": true, \"editable\": true}\n# Cleanup - here we make our job easy and just remove all\n# stations for which we don't have data for all events.\n# Real implementations will of course have to deal with this.\n\ncommon_stations = set.intersection(*[set((tr.stats.network, tr.stats.station)\n                                         for tr in value[\"observed_stream\"])\n                                     for value in data.values()])\nprint(len(common_stations))\n\nfor value in data.values():\n    value[\"observed_stream\"] = obspy.Stream(traces=[\n        tr for tr in value[\"observed_stream\"] if\n        (tr.stats.network, tr.stats.station) in common_stations])\n    value[\"synthetic_stream\"] = obspy.Stream(traces=[\n        tr for tr in value[\"synthetic_stream\"] if\n        (tr.stats.network, tr.stats.station) in common_stations])\n\n# + {\"deletable\": true, \"editable\": true}\n# Create a new inventory object which only contains the common stations.\nfrom copy import deepcopy\nfiltered_inv = deepcopy(inv)\nfiltered_inv[0].stations = [_i for _i in filtered_inv[0].stations if (\"CI\", _i.code) in common_stations]\nfiltered_inv.plot(projection=\"local\");\n\n# + {\"deletable\": true, \"editable\": true}\nfrom obspy.signal.cross_correlation import xcorr_pick_correction\n\n\ncollected_stats = []\n\ngood_data = data\n\n# Now calculate the P phase delay for all stations.\nfor network, station in common_stations:\n    print(network, station)\n    for event, this_data in good_data.items():\n        obs_tr = this_data[\"observed_stream\"].select(network=network, station=station)[0].copy()\n        syn_tr = this_data[\"synthetic_stream\"].select(network=network, station=station)[0].copy()\n\n        # Artificially shift the data for two stations for the \"application\" event.\n        if event.id == application:\n            if station == \"BEL\":\n                obs_tr.stats.starttime -= 1.0\n            if station == \"PHL\":\n                obs_tr.stats.starttime += 1.0\n\n        # p-phase should be centered in the synthetic trace.\n        pick = syn_tr.stats.starttime + (syn_tr.stats.endtime - syn_tr.stats.starttime) / 2.0\n\n        # Process data.\n        obs_tr.detrend(\"linear\")\\\n            .taper(max_percentage=0.05, type=\"hann\")\\\n            .remove_response(inventory=filtered_inv, pre_filt=(0.02, 0.01, 1, 5))\\\n            .filter(\"bandpass\", freqmin=0.08, freqmax=0.2, corners=4, zerophase=True)\\\n            ._ltrim(30.0)\\\n            ._rtrim(30.0)\\\n            .taper(max_percentage=0.3, type=\"hann\")\n        obs_tr.trim(obs_tr.stats.starttime - 50, obs_tr.stats.endtime + 50, pad=True, fill_value=0.0)\n\n        # Also filter the synthetics.\n        syn_tr.taper(max_percentage=0.05, type=\"hann\")\n        syn_tr.filter(\"bandpass\", freqmin=0.08, freqmax=0.2, corners=4, zerophase=True)\n        syn_tr.data = np.require(syn_tr, requirements=[\"C\"])\n\n        # Interpolate both to the same sample points.\n        starttime = max(obs_tr.stats.starttime, syn_tr.stats.starttime)\n        endtime = min(obs_tr.stats.endtime, syn_tr.stats.endtime)\n        npts = int((endtime - starttime) // (1.0 / 40.0) - 1)\n        obs_tr.interpolate(sampling_rate=40.0, method=\"lanczos\", a=5,\n                           starttime=starttime, npts=npts)\n        syn_tr.interpolate(sampling_rate=40.0, method=\"lanczos\", a=5,\n                           starttime=starttime, npts=npts)\n\n        print(event.id, network, station)\n\n        # Subsample precision.\n        try:\n            shift, corr = xcorr_pick_correction(pick, obs_tr, pick, syn_tr, t_before=20,\n                                                t_after=20, cc_maxlag=12)\n        except:\n            shift, corr = None, None\n        collected_stats.append({\"time_shift\": shift, \"correlation\": corr,\n                                \"network\": network, \"station\": station, \"event\": event.id})\n\n        if \"processed_observed_stream\" not in this_data:\n            this_data[\"processed_observed_stream\"] = obspy.Stream()\n\n        this_data[\"processed_observed_stream\"] += obs_tr\n\n        if \"processed_synthetic_stream\" not in this_data:\n            this_data[\"processed_synthetic_stream\"] = obspy.Stream()\n\n        this_data[\"processed_synthetic_stream\"] += syn_tr\n\n\n# + {\"deletable\": true, \"editable\": true}\nimport pandas\npandas.set_option('display.max_rows', 10)\ncs = pandas.DataFrame(collected_stats)\noriginal_cs = pandas.DataFrame(collected_stats)\n\n# + {\"deletable\": true, \"editable\": true}\n# Now for all events: substract the mean time shift to account for\n# unexplained structure and unknown origin time.\ncs.loc[:, \"time_shift\"] = cs.groupby(\"event\").time_shift.transform(lambda df: df - df.mean())\ncs = cs.sort_values(\"station\")\ncs\n\n# + {\"deletable\": true, \"editable\": true}\n# Calculate the reference time shift for each station.\nreference_shifts = dict(cs.loc[cs.event.isin(training)].groupby(\"station\").time_shift.mean())\nreference_shifts\n\n# + {\"deletable\": true, \"editable\": true}\nimport matplotlib.pyplot as plt\n\ndef check_event(event, ax=None, ticks=False):\n    _ds = cs[cs.event == event]\n    mean = _ds.time_shift.mean()\n\n    things = []\n\n    for _i in _ds.itertuples():\n        things.append({\"station\": _i.station,\n                       \"time_shift\": _i.time_shift - mean,\n                       \"difference_to_mean\": (_i.time_shift - mean) - reference_shifts[_i.station]})\n\n    temp = pandas.DataFrame(things).sort_values(\"station\")\n\n    if ax is None:\n        plt.figure(figsize=(15, 5))\n        ax = plt.gca()\n    plt.bar(np.arange(len(_ds)) - 0.4, temp.difference_to_mean, 0.8, color=\"0.2\")\n    plt.ylim(-1.4, 1.4)\n    if ticks:\n        plt.xticks(range(len(_ds)), temp.station, rotation=\"vertical\")\n    else:\n        plt.xticks(range(len(_ds)), [\"\"] * len(_ds), rotation=\"vertical\")\n\n    plt.xlim(-1, 23)\ncheck_event(application)\n\n# + {\"deletable\": true, \"editable\": true}\ncheck_event(validate)\n\n# + {\"deletable\": true, \"editable\": true}\ncheck_event(application)\n\n\n# + {\"deletable\": true, \"editable\": true}\ndef plot_data(event, station, show=True, legend=False):\n    val = data[obspy.core.event.ResourceIdentifier(event)]\n    obs = val[\"processed_observed_stream\"].select(station=station)[0]\n    syn = val[\"processed_synthetic_stream\"].select(station=station)[0]\n\n    plt.plot(obs.times(), obs.data * 1E6, color=\"0.3\", linestyle=\"--\", linewidth=5,\n             label=\"Observed Data\")\n    plt.plot(syn.times(), syn.data * 1E6, color=\"0.1\", linestyle=\":\", label=\"Synthetic Data\")\n\n    ts= original_cs[(original_cs.event == validate) &\n                    (original_cs.station == \"TIN\")].time_shift\n\n    plt.plot(syn.times() - float(ts), syn.data * 1E6, color=\"k\", label=\"Shifted Synthetic Data\")\n    plt.ylabel(\"Velocity [$\\mu$m/s]\")\n    plt.xlabel(\"Relative Time [s]\")\n    plt.xlim(20, 65)\n\n    plt.xticks([30, 40, 50, 60], [\"30\", \"40\", \"50\", \"60\"])\n\n    if legend:\n        plt.legend(loc=\"lower left\")\n\n    plt.text(0.03, 0.92, \"Station: CI.%s\" % station, transform=plt.gca().transAxes, va=\"top\")\n    if show:\n        plt.show()\n\nplot_data(validate, \"TIN\")\nplot_data(validate, \"SCI2\")\nplot_data(validate, \"MPP\")\n\n# + {\"deletable\": true, \"editable\": true}\n# Create final complete plot.\nimport matplotlib.gridspec as gridspec\n\nfig = plt.figure(figsize=(10, 5))\n\ngs1 = gridspec.GridSpec(2, 1, wspace=0, hspace=0.04, left=0, right=0.27, bottom=0.08, top=0.98)\nax1 = fig.add_subplot(gs1[0])\nax2 = fig.add_subplot(gs1[1])\n\n\ngs2 = gridspec.GridSpec(3, 1, wspace=0, hspace=0, left=0.32, right=0.62, bottom=0.08, top=0.98)\nax3 = fig.add_subplot(gs2[0])\nax4 = fig.add_subplot(gs2[1])\nax5 = fig.add_subplot(gs2[2])\n\ngs3 = gridspec.GridSpec(3, 1, wspace=0, hspace=0, left=0.64, right=0.94, bottom=0.08, top=0.98)\nax6 = fig.add_subplot(gs3[0])\nax7 = fig.add_subplot(gs3[1])\nax8 = fig.add_subplot(gs3[2])\n\n\n\n\nstation_lats = [sta.latitude for net in filtered_inv for sta in net]\nstation_lngs = [sta.longitude for net in filtered_inv for sta in net]\n\nev_lats = [event.origins[0].latitude for event in cat]\nev_lngs = [event.origins[0].longitude for event in cat]\n\n\nm_ortho = Basemap(resolution='c', projection='ortho', lat_0=10.,\n                  lon_0=-150., ax=ax1)\nm_ortho.drawcoastlines(color=\"0.3\", linewidth=1.0)\nm_ortho.drawcountries(color=\"0.8\")\nm_ortho.fillcontinents(color=\"0.9\")\n\n_xs, _ys = m_ortho(station_lngs, station_lats)\n_xe, _ye = m_ortho(ev_lngs, ev_lats)\n\nfor sta, ev in itertools.product(zip(station_lngs, station_lats),\n                                 zip(ev_lngs, ev_lats)):\n    m_ortho.drawgreatcircle(*sta, *ev, linewidth=1.2,\n                            color=\"0.6\", alpha=0.5)\n\nm_ortho.scatter(_xs, _ys, marker=\"v\", s=120, zorder=10,\n                color=\"k\", edgecolor=\"w\")\nm_ortho.scatter(_xe, _ye, marker=\"o\", s=120, zorder=10,\n                color=\"k\", edgecolor=\"w\")\n\n\ndeg2m = 2 * np.pi * 6371 * 1000 / 360\nm_local = Basemap(projection='aea',\n                  resolution=\"i\",\n                  area_thresh=1000.0, lat_0=34.9,\n                  lon_0=-118,\n                  width=deg2m * 8, height=deg2m * 8,\n                  ax=ax2)\nm_local.drawmapboundary()\nm_local.drawrivers(color=\"0.7\")\nm_local.drawcoastlines(color=\"0.3\", linewidth=1.4)\nm_local.drawcountries(color=\"0.4\", linewidth=1.1)\nm_local.fillcontinents(color=\"0.9\")\nm_local.drawstates(color=\"0.5\", linewidth=0.9)\n\n_x, _y = m_local(station_lngs, station_lats)\nm_local.scatter(_x, _y, marker=\"v\", s=140, zorder=10,\n                color=\"k\", edgecolor=\"w\")\n\n\n# Waveforms.\nplt.sca(ax3)\nplot_data(validate, \"TIN\", show=False)\nplt.yticks(np.linspace(-1.5, 1.5, 7))\n\nplt.sca(ax4)\nplot_data(validate, \"SCI2\", show=False)\nplt.yticks(np.linspace(-2, 2, 9))\n\n\nplt.sca(ax5)\nplot_data(validate, \"MPP\", show=False, legend=True)\nplt.yticks(np.linspace(-2, 2, 9))\n\n\nplt.sca(ax6)\nstations = list(reference_shifts.keys())\ndelays = [reference_shifts[_i] for _i in stations]\nplt.bar(np.arange(len(delays)) - 0.4, delays, 0.8, color=\"0.2\")\nplt.xticks(range(len(delays)), [\"\"] * len(delays))\nax6.yaxis.tick_right()\nax6.yaxis.set_label_position(\"right\")\nplt.xlim(-1, 23)\nplt.ylim(-0.8, 0.7)\nplt.yticks([-0.5, 0, 0.5])\nplt.ylabel(\"Average time shift [s]\")\nplt.text(0.97, 0.90, \"Reference Time Shifts\", transform=plt.gca().transAxes, va=\"top\", ha=\"right\")\n\n\n\nplt.sca(ax7)\ncheck_event(validate, ax=ax7)\nax7.yaxis.tick_right()\nax7.yaxis.set_label_position(\"right\")\nplt.yticks(np.linspace(-1.0, 1.0, 5))\nplt.ylabel(\"Time shift deviation [s]\")\nplt.text(0.97, 0.90, \"Validation Event\", transform=plt.gca().transAxes, va=\"top\", ha=\"right\")\n\n\n\n\nplt.sca(ax8)\ncheck_event(application, ax=ax8, ticks=True)\nax8.yaxis.tick_right()\nax8.yaxis.set_label_position(\"right\")\nplt.yticks(np.linspace(-1.0, 1.0, 5))\nplt.ylabel(\"Time shift deviation [s]\")\nplt.text(0.97, 0.90, \"Test Event\", transform=plt.gca().transAxes, va=\"top\", ha=\"right\")\n\n\nplt.savefig(\"data_quality.pdf\")\nplt.show()\n", "meta": {"hexsha": "7d9fe0495997795517e05ca413bede49a96b149b", "size": 15997, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks/Reproducible Papers/Syngine_2016/figure_6_data_quality.py", "max_stars_repo_name": "krischer/seismo_live_build", "max_stars_repo_head_hexsha": "e4e8e59d9bf1b020e13ac91c0707eb907b05b34f", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-07-11T10:01:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-16T14:26:03.000Z", "max_issues_repo_path": "notebooks/Reproducible Papers/Syngine_2016/figure_6_data_quality.py", "max_issues_repo_name": "krischer/seismo_live_build", "max_issues_repo_head_hexsha": "e4e8e59d9bf1b020e13ac91c0707eb907b05b34f", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "notebooks/Reproducible Papers/Syngine_2016/figure_6_data_quality.py", "max_forks_repo_name": "krischer/seismo_live_build", "max_forks_repo_head_hexsha": "e4e8e59d9bf1b020e13ac91c0707eb907b05b34f", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-11-11T05:05:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-12T09:36:24.000Z", "avg_line_length": 36.2743764172, "max_line_length": 159, "alphanum_fraction": 0.6524348315, "include": true, "reason": "import numpy", "num_tokens": 4529, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657963619520866, "lm_q2_score": 0.1112412050343159, "lm_q1q2_score": 0.053015293025170884}}
{"text": "![Callysto.ca Banner](https://github.com/callysto/curriculum-notebooks/blob/master/callysto-notebook-banner-top.jpg?raw=true)\n\n<a href=\"https://hub.callysto.ca/jupyter/hub/user-redirect/git-pull?repo=https%3A%2F%2Fgithub.com%2Fcallysto%2Fcurriculum-notebooks&branch=master&subPath=Science/StaticAndKineticFriction/StaticAndKineticFriction.ipynb&depth=1\" target=\"_parent\"><img src=\"https://raw.githubusercontent.com/callysto/curriculum-notebooks/master/open-in-callysto-button.svg?sanitize=true\" width=\"123\" height=\"24\" alt=\"Open in Callysto\"/></a>\n\n(Click **Cell** > **Run All** before proceeding.)\n\n%matplotlib inline\n\n#----------\n#Import modules and packages \nimport ipywidgets as widgets\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport random\n\n#----------\n\n#import ipywidgets as widgets\n#import random\n\n#This function produces a multiple choice form with four options\ndef multiple_choice(option_1, option_2, option_3, option_4):\n    option_list = [option_1, option_2, option_3, option_4]\n    answer = option_list[0]\n    letters = [\"(A) \", \"(B) \", \"(C) \", \"(D) \"]\n\n    #Boldface letters at the beginning of each option\n    start_bold = \"\\033[1m\"; end_bold = \"\\033[0;0m\"\n\n    #Randomly shuffle the options\n    random.shuffle(option_list)\n    \n    #Prints the letters (A) to (D) in sequence with randomly chosen options\n    for i in range(4):\n        option_text = option_list.pop()\n        print(start_bold + letters[i] + end_bold + option_text)\n\n        #Stores the correct answer\n        if option_text == answer:\n            letter_answer = letters[i]\n\n    button1 = widgets.Button(description=\"(A)\"); button2 = widgets.Button(description=\"(B)\")\n    button3 = widgets.Button(description=\"(C)\"); button4 = widgets.Button(description=\"(D)\")\n    \n    button1.style.button_color = 'Whitesmoke'; button2.style.button_color = 'Whitesmoke'\n    button3.style.button_color = 'Whitesmoke'; button4.style.button_color = 'Whitesmoke'\n    \n    container = widgets.HBox(children=[button1,button2,button3,button4])\n    display(container)\n    print(\" \", end='\\r')\n\n    def on_button1_clicked(b):\n        if \"(A) \" == letter_answer:\n            print(\"Correct!    \", end='\\r')\n            button1.style.button_color = 'Moccasin'; button2.style.button_color = 'Whitesmoke'\n            button3.style.button_color = 'Whitesmoke'; button4.style.button_color = 'Whitesmoke'\n        else:\n            print(\"Try again.\", end='\\r')\n            button1.style.button_color = 'Lightgray'; button2.style.button_color = 'Whitesmoke'\n            button3.style.button_color = 'Whitesmoke'; button4.style.button_color = 'Whitesmoke'\n\n    def on_button2_clicked(b):\n        if \"(B) \" == letter_answer:\n            print(\"Correct!    \", end='\\r')\n            button1.style.button_color = 'Whitesmoke'; button2.style.button_color = 'Moccasin'\n            button3.style.button_color = 'Whitesmoke'; button4.style.button_color = 'Whitesmoke'\n        else:\n            print(\"Try again.\", end='\\r')\n            button1.style.button_color = 'Whitesmoke'; button2.style.button_color = 'Lightgray'\n            button3.style.button_color = 'Whitesmoke'; button4.style.button_color = 'Whitesmoke'\n\n    def on_button3_clicked(b):\n        if \"(C) \" == letter_answer:\n            print(\"Correct!    \", end='\\r')\n            button1.style.button_color = 'Whitesmoke'; button2.style.button_color = 'Whitesmoke'\n            button3.style.button_color = 'Moccasin'; button4.style.button_color = 'Whitesmoke'\n        else:\n            print(\"Try again.\", end='\\r')\n            button1.style.button_color = 'Whitesmoke'; button2.style.button_color = 'Whitesmoke'\n            button3.style.button_color = 'Lightgray'; button4.style.button_color = 'Whitesmoke'\n\n    def on_button4_clicked(b):\n        if \"(D) \" == letter_answer:\n            print(\"Correct!    \", end='\\r')\n            button1.style.button_color = 'Whitesmoke'; button2.style.button_color = 'Whitesmoke'\n            button3.style.button_color = 'Whitesmoke'; button4.style.button_color = 'Moccasin'\n        else:\n            print(\"Try again.\", end='\\r')\n            button1.style.button_color = 'Whitesmoke'; button2.style.button_color = 'Whitesmoke'\n            button3.style.button_color = 'Whitesmoke'; button4.style.button_color = 'Lightgray'\n\n    button1.on_click(on_button1_clicked); button2.on_click(on_button2_clicked)\n    button3.on_click(on_button3_clicked); button4.on_click(on_button4_clicked)\n\n# Static and Kinetic Friction\n\n## Introduction\n\n**Friction** is the name given to the force that resists the relative motion of one object as it slides against another. Most surfaces are rough and uneven. Even smooth surfaces, such as a polished mirror, can appear bumpy under a microscope. The bumps on these surfaces interlock as they rub against one another, which prevents them from sliding freely.\n\n<img src=\"Images/rough_surfaces.svg\" width=\"35%\"/>\n\nThe more an object presses into a surface, the more the surface pushes back against the object. The force pushing back against the object is called the **normal force**, **$F_{n}$** and it is always perpendicular to the surface. From the image above, we can imagine that the more two objects are pressed together, the more difficult it is for the interlocking points to lift up and slide passed one another. As a consequence, the friction force increases. A relationship therefore exists between the magnitude of the friction force and that of the normal force. This relationship is expressed by the following equation: \n\n$$F_{f}=\\mu F_{n}$$\n\nwhere $F_{f}$ and $F_{n}$ are the magnitudes of the friction and normal forces respectively, and $\\mu$ is the **coefficient of friction**. Here $\\mu$ is the Greek letter $mu$.  The direction of the force of friction is parallel to the surface and opposite to the other forces acting on the object.\n\nUse the slider below to observe the relationship between the normal force and the friction force. Pick any value for the coefficient of friction. Move the slider for the normal force back and forth to calculate the corresponding force of friction. \n\n#import ipywidgets as widgets\n\ncoeff = widgets.FloatSlider(description=\"Coefficient\",min=0.1,max=0.9)\nnormal_force = widgets.IntSlider(description=\"Normal force\",min=5,max=50)\n\n#Boldface letters at the beginning of each option\nstart_bold = \"\\033[1m\"; end_bold = \"\\033[0;0m\"\n\ndef f(coeff, normal_force):\n    friction_force = coeff * normal_force\n    print(start_bold + \"Friction force = (coefficient of friction) X (normal force)\" + end_bold)\n    print(\"Friction force = {} X {} = {} N\".format(coeff, normal_force, round(friction_force,1)))\n\nout = widgets.interactive_output(f,{'coeff': coeff, 'normal_force': normal_force})\n\nwidgets.HBox([widgets.VBox([coeff, normal_force]), out])\n\n**Question:** *What happens to the friction force when the normal force increases?* \n\n#import ipywidgets as widgets\n\n#Assign each multiple choice to these four variables\n#Option_1 contains the answer\noption_1 = \"The friction force increases.\" \noption_2 = \"The friction force decreases.\"\noption_3 = \"The friction force remains constant.\"\noption_4 = \"The friction force equals zero.\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\nThe force of friction felt by an object depends on whether the objects are in motion with respect to each other.  In general the force of friction felt by an object which is not moving with respect to another is stronger than the force of friction felt once it begins moving.\n\n**Static friction** describes the friction force that acts between an object and a surface to prevent it from sliding when a force is applied to it. Static friction applies to objects that are stationary with respect to one another.  \n\n**Kinetic friction** describes the friction force that acts between an object and the surface it slides upon when a force is applied to it. Kinetic friction applies to objects that are in motion with respect to one another.\n\n### Coefficients of Friction\n\nValues for the coefficients of friction have been derived experimentally for various materials as they interact with one another. When we describe the friction acting on a stationary object, we must use the **coefficient of static friction, $\\mu_{s}$**. When we describe the friction of a sliding object, we must use the **coefficient of kinetic friction, $\\mu_{k}$**. Some values for the coefficients of static and kinetic friction are shown in the table below:  \n\n Materials          | Coefficients of static friction ($\\mu_{s}$)| Coefficients of kinetic friction ($\\mu_{k}$) \n ---                | ---                                       | ---\n Steel on steel     | 0.7                                       | 0.6 \n Glass on glass     | 0.9                                       | 0.4\n Wood on wood       | 0.4                                       | 0.2 \n Rubber on concrete | 1.0                                       | 0.8\n\nUse the slider again to observe the relationship between the coefficient of friction and the friction force. Pick any value for the normal force. Move the slider for the coefficient of friction back and forth to calculate the corresponding force of friction. \n\n#import ipywidgets as widgets\n\ncoeff = widgets.FloatSlider(description=\"Coefficient\",min=0.1,max=0.9)\nnormal_force = widgets.IntSlider(description=\"Normal force\",min=5,max=50)\n\n#Boldface letters at the beginning of each option\nstart_bold = \"\\033[1m\"; end_bold = \"\\033[0;0m\"\n\ndef f(coeff, normal_force):\n    friction_force = coeff * normal_force\n    print(start_bold + \"Friction force = (coefficient of friction) X (normal force)\" + end_bold)\n    print(\"Friction force = {} X {} = {} N\".format(coeff, normal_force, round(friction_force,1)))\n\nout = widgets.interactive_output(f,{'coeff': coeff, 'normal_force': normal_force})\n\nwidgets.HBox([widgets.VBox([coeff, normal_force]), out])\n\n**Question:** *What happens to the friction force when the coefficient of friction increases?*\n\n#import ipywidgets as widgets\n\n#Assign each multiple choice to these four variables\n#Option_1 contains the answer\noption_1 = \"The friction force increases.\" \noption_2 = \"The friction force decreases.\"\noption_3 = \"The friction force remains constant.\"\noption_4 = \"The friction force equals zero.\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\nIt is to be noted that the amount $\\mu_s F_{n}$ is actually the **maximal value** for the magnitude of **static** friction $F_{f}$.  Assuming the forces acting on an object are insufficient to overcome this maximal value, the object will be stationary.  In this case, the actual magnitude of the force of static friction, $F_{f}$, will typically be less than maximal; it is exactly that amount required to have a net force of zero so that the object does not move.  \n\n### Solving Friction Problems\n\nWhen solving a friction problem, it is useful to construct a free-body diagram. A **free-body diagram** is a simple graphical representation of an object and all the relevant forces acting upon it. An example of a free-body diagram is shown below:\n\n<img src=\"Images/free_body_diagram.svg\" width=\"45%\"/>\n\n* $F_{a}$ represents the **applied force**: the force acting in the direction of motion of the object.\n* $F_{f}$ represents the **friction force**: the force acting in the direction opposite to the motion of the object.\n* $mg$ represents the weight: the force of gravity acting on the object. Here, $m$ is the mass of the object, and $g$ is the gravitational acceleration directed downwards and of magnitude $g=9.8\\:m/s^2$.\n* $F_{n}$ represents the normal force: the force perpendicular to the surface pressing up against the object.\n\n### Example\nA 10 kg object is pushed across a flat horizontal surface with an applied force of 25 N. The same object is later pushed again with an applied force of 50 N. The coefficients of static and kinetic frictions are 0.40 and 0.30, respectively. Calculate the friction force ($F_{f}$) at each of the applied forces. Use the formula: $F_{f}=\\mu F_{n}$.\n\n**Step 1:** *Construct a free-body diagram*. The free-body diagram shown above may be used for this example. \n\n**Step 2:** *Calculate the known forces*: **Recall:** The weight of the object, $mg$, is equal to the mass of the object multiplied by the acceleration due to gravity.\n\n$$mg = (10 \\times 9.8)\\:N = 98\\:N$$\n\nSince there is no vertical acceleration on the object, the total vertical force must vanish so the magnitude of the normal force must be equal to that of the weight of the object ($F_{n} = mg$). Therefore, \n\n$$F_{n} = mg = (10 \\times 9.8)\\:N = 98\\:N$$\n\n**Step 3:** *Determine the maximum static friction force*: Now that the normal force is known, we can calculate the maximum static friction force using the following equation:\n\n$$F_{s}=\\mu_{s} F_{n} = (0.40 \\times 98)\\:N = 39\\:N$$\n\nThis means that the object will resist up to 39 N of applied force before it begins to move. \n\n**Step 4:** *Determine the friction force at 25 N*: Since the applied force of 25 N is less than the maximum static friction force, the object will remain stationary. The friction will oppose the applied force up to 25 N. Therefore, \n\n$$F_{f} = 25\\:N$$\n\nThe direction of $F_{f}$ will be opposite to the direction of the applied force.\n    \n**Step 5:** *Determine the friction force at 50 N*: Since the applied force of 50 N is greater than the maximum static friction force, the object will begin to move. When in motion, the object is no longer being opposed by the static friction force. Instead it is being opposed by the kinetic friction force. We can calculate the kinetic friction force using the following equation:\n\n$$F_{k}=\\mu_{k} F_{n} = (0.30 \\times 98)\\:N = 29\\:N$$\n\nTherefore, the magnitude of the friction force will be:\n\n$$F_{f} = 29\\:N$$\n\nOnce again, the direction of $F_{f}$ will be opposite to the direction of the applied force.\n\n**Answer:** At an applied force of 25 N, the object is stationary and the magnitude of the friction force is 25 N. At an applied force of 50 N, the object is in motion and the magnitude of the friction force is 29 N. In both cases, the force of friction is directed parallel to the surface and opposite to the direction of the applied force.  \n\n## Practice Problems\n(Click **Cell** > **Run Cells** to generate new random values for each question. Refer to the previous table to get the coefficients of friction for specific materials.)\n\n#import random\n#import ipywidgets as widgets\n\n#Randomize mass and friction coefficient\nmass = random.randint(20,50)\ncoeff = (random.randint(10,100))/100\n\n#Print question\nquestion = \"A \" + str(mass) +\" kg object is pushed across a flat horizontal surface. The coefficient of kinetic friction between the moving object and the surface is \" + str(coeff) +\". What is the magnitude of the friction force?\"\nprint(question)\n\n#Answer calculation\n#Friction force = (friction coefficient) X (normal force)\nanswer = coeff*(mass*9.8)\nanswer = round(answer)\n\n#Define range of values for random multiple choices\nmin = int(coeff*((mass-15)*9.8))  \nmax = int(coeff*((mass+15)*9.8))\n\n#Create three choices that are unique (and not equal to the answer)\nchoice_list = random.sample(range(min,max),3)\nwhile choice_list.count(answer) >= 1:\n    choice_list = random.sample(range(min,max),3)\n    \n#Assign each multiple choice to these four variables\n#Option_1 contains the answer\noption_1 = str(answer) + \" N\" \noption_2 = str(choice_list[0]) + \" N\"\noption_3 = str(choice_list[1]) + \" N\"\noption_4 = str(choice_list[2]) + \" N\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\n#import random\n#import ipywidgets as widgets\n\n#Randomize mass and applied force\nmass = random.randint(20,50)\napplied_force = random.randint(150,300)\n\n#Randomize material\nmaterial_options = ['steel', 'glass', 'wood']\nmaterial =random.choice(material_options)\n\n#Define friction coefficients based on selected material \nif material == 'steel':\n    us = 0.7; uk = 0.6\nelif material == 'glass':\n    us = 0.9; uk = 0.4 \nelif material == 'wood':\n    us = 0.4; uk = 0.2 \n\n#Print question\nquestion = \"If a %d kg %s object is pushed across a flat horizontal %s surface with an applied force of %d N, what is the magnitude of the friction force?\" %(mass, material, material, applied_force)\nprint(question)\n\n#Answer calculation\n#Friction force = (friction coefficient) X (normal force)\nstatic_friction = us*(mass*9.8)\nkinetic_friction = uk*(mass*9.8)\n\n#If the applied force is less than or equal to the maximum static friction force, the object will remain stationary\n#The friction force equals the applied force\nif applied_force <= static_friction:\n    answer = applied_force\nelse:\n    answer = kinetic_friction\n\nanswer = round(answer)    \n    \n#Define range of values for random multiple choices\nif applied_force <= static_friction:\n    min = applied_force-15  \n    max = applied_force+15\nelse:\n    min = int(uk*((mass-15)*9.8))  \n    max = int(uk*((mass+15)*9.8))\n\n#Create three choices that are unique (and not equal to the answer) \nchoice_list = random.sample(range(min,max),3)\nwhile choice_list.count(answer) >= 1:\n    choice_list = random.sample(range(min,max),3)\n\n#Assign each multiple choice to these four variables\n#Option_1 contains the answer\noption_1 = str(answer) + \" N\" \noption_2 = str(choice_list[0]) + \" N\"\noption_3 = str(choice_list[1]) + \" N\"\noption_4 = str(choice_list[2]) + \" N\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\n#import random\n#import ipywidgets as widgets\n\n#Randomize applied and friction forces\napplied_force = random.randint(51,75)\nfriction_force = random.randint(25,50)\n\n#Randomize material\nmaterial_options = ['steel', 'glass', 'wood']\nmaterial =random.choice(material_options)\n\n#Define friction coefficients based on selected material \nif material == 'steel':\n    uk = 0.6; us = 0.7\nelif material == 'glass':\n    uk = 0.4; us = 0.9\nelif material == 'wood':\n    uk = 0.2; us = 0.4\n\n#Print question\nquestion = \"If a %s object is pushed across a flat horizontal %s surface with an applied force of %d N, and a friction force of %d N occurs, what is the magnitude of the normal force?\" %(material, material, applied_force, friction_force)\nprint(question)\n\n#Answer calculation\n#weight = normal force = (friction force)/(kinetic friction coefficient)\nanswer = friction_force/uk\nanswer = round(answer)\n\n#Define range of values for random multiple choices\nmin = int((friction_force-15)/uk); max = int((friction_force+15)/uk)\n\n#Create three choices that are unique (and not equal to the answer) \nchoice_list = random.sample(range(min,max),3)\nwhile choice_list.count(answer) >= 1:\n    choice_list = random.sample(range(min,max),3)\n\n#Assign each option to these four variables\n#Option1 contains the answer\noption_1 = str(answer) + \" N\" \noption_2 = str(random.randint(min,max)) + \" N\"\noption_3 = str(random.randint(min,max)) + \" N\"\noption_4 = str(random.randint(min,max)) + \" N\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\n#import random\n#import ipywidgets as widgets\n#import numpy as np\n\n#Randomize mass and applied force\nmass = random.randint(5,10)\napplied_force = random.randint(46,80)\nfriction_force = random.randint(10,45)\n\n#Print question\nquestion = \"A %d kg object is pulled across a flat horizontal surface by a force of %d N. The friction force is %d N. What is the coefficient of kinetic friction?\" %(mass, applied_force, friction_force)\nprint(question)\n\n#Answer calculation\n#friction coefficient = (friction force) / (normal force)\nanswer = friction_force/(mass*9.8)\nanswer = round(answer,2)\n\n#Define range of values for random multiple choices\nmin = 0.1\nmax = 0.9\nunique = 0\n\n#Create three choices that are unique (and not equal to the answer) \nwhile unique < 4:\n    choice_list = np.random.uniform(min, max, size=(3,))\n    for i in range(3):\n        choice_list[i] = round(choice_list[i],2)\n        \n    choice_list = np.append(choice_list, answer)\n    list_unique = np.unique(choice_list)\n    unique = list_unique.size\n\n#Assign each multiple choice to these four variables\n#Option_1 contains the answer\noption_1 = str(answer) \noption_2 = str(choice_list[0])\noption_3 = str(choice_list[1])\noption_4 = str(choice_list[2])\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\nUse the diagram below to answer the following question:\n\n<img src=\"Images/free_body_diagram_pulley.svg\" width=\"45%\"/>\n\n#import random\n#import ipywidgets as widgets\n\n#Randomize mass and friction coefficient\nmass = random.randint(20,50)\ncoeff = (random.randint(10,100))/100\n\n#Print question\nquestion = \"A \" + str(mass) +\" kg object is suspended by a pulley and connected to an object resting on a flat surface. The friction coefficient between the object and the surface is \" + str(coeff) +\". What is the minimum mass required to keep this suspended object stationary?\"\nprint(question)\n\n#Answer calculation\n#Friction force = applied force = (mass) X (9.8)\nfriction_force = mass*9.8\n\nnormal_force = friction_force/coeff\nanswer = normal_force/9.8\nanswer = round(answer)\n\n#Define range of values for random multiple choices\nmin = int((normal_force-50)/9.8)  \nmax = int((normal_force+50)/9.8)\n\n#Create three choices that are unique (and not equal to the answer)\nchoice_list = random.sample(range(min,max),3)\nwhile choice_list.count(answer) >= 1:\n    choice_list = random.sample(range(min,max),3)\n    \n#Assign each multiple choice to these four variables\n#Option_1 contains the answer\noption_1 = str(answer) + \" N\" \noption_2 = str(choice_list[0]) + \" N\"\noption_3 = str(choice_list[1]) + \" N\"\noption_4 = str(choice_list[2]) + \" N\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\n## Experiment \n\nAs mentioned above, the coefficients of static and kinetic friction are determined experimentally for different materials.\n\n**Determination of Static Friction**\n\nTry the following experiment to determine the coefficient of static friction.\n\n**Step 1:** Find an object and a flat horizontal surface. Record the material type for the object and surface.\n\n**Step 2:** Measure the mass of the object using a mass balance (kg). \n\n**Step 3:** Calculate the magnitude of the normal force using the following formula: $F_{n} = mg$\n\n**Step 4:** Using a spring scale, gradually apply a force to the object. Record the value on the scale the moment the object begins to move. At this moment, the applied force is equal to the maximum static friction force.\n\n<img src=\"Images/free_body_diagram_spring.svg\" width=\"55%\"/>\n\n**Step 5:** Calculate the coefficient of static friction using the following formula: $\\mu_{s} = F_{f} \\div F_{n}$\n\n**Determination of Kinetic Friction**\n\nContinue the experiment to determine the coefficient of kinetic friction.\n\n**Step 6:** Using a spring scale, apply enough force to drag the object across the surface at a constant velocity (acceleration = 0). Record the value on the scale while the object is moving. So long as the object moves at a constant velocity, the applied force is equal to the kinetic friction force. \n\n**Step 7:** Calculate the coefficient of kinetic friction using the following formula: $\\mu_{k} = F_{f} \\div F_{n}$\n\n (**Double click** this cell and update the table with your own data. Click **Cell** > **Run Cells** when done.)\n \nMaterials | Object mass (g) | Normal force (N) | Applied force (N) | Static friction coefficient | Kinetic friction coefficient \n ---      | ---             | ---              | ---               | ---                         | ----   \n ?        | ?               | ?                | ?                 | ?                           | ?      \n ?        | ?               | ?                | ?                 | ?                           | ?      \n ?        | ?               | ?                | ?                 | ?                           | ?\n ?        | ?               | ?                | ?                 | ?                           | ?      \n ?        | ?               | ?                | ?                 | ?                           | ? \n\n## Force Diagrams\n\nA useful way to visualize the friction forces is to construct a force diagram, as shown below. This diagram depicts the magnitudes of the forces acting on an object as it is pushed across a flat horizontal surface with increasing force. The y-axis depicts the friction force ($F_{f}$), and the x-axis depicts the applied force ($F_{a}$). The sliders can be manipulated to change the normal force ($F_{n}$), the coefficient of static friction ($\\mu_{s}$), and the coefficient of kinetic friction ($\\mu_{k}$). \n\n#import ipywidgets as widgets\n#import matplotlib.pyplot as plt\n\ndef f(Fn=50,μs=0.75,μk=0.25):\n    #Fn = normal force\n    #μs = coefficient of static friction\n    #μk = coefficient of kinetic friction\n    \n    plt.figure()\n    xs = Fn*μs\n    xk = Fn*μk\n    plt.plot([0,xs,xs,100],[0,xs,xk,xk])\n    plt.plot([xs,xs],[xk,0], linestyle=\"dotted\")\n    plt.ylim(0, 100)\n    plt.xlim(0,100)\n    plt.ylabel('Friction force (N)')\n    plt.xlabel('Applied force (N)')\n    plt.annotate(xy=[xs-15,xs+5],s=\"Static friction (max)\")\n    plt.annotate(xy=[(xs+(100-xs)/2)-10,xk+5],s=\"Kinetic friction\")\n    plt.show()\n\ninteractive_plot = widgets.interactive(f,Fn=(35,75,5),μs=(0.5, 1.0),μk=(0.1, 0.5))\noutput = interactive_plot.children[-1]\noutput.layout.height = '280px'\ninteractive_plot\n\n**Interpreting the graph**\n\nRead the graph from left to right. As the applied force gradually increases along the x-axis, the friction force also increases. Notice that the magnitude of the friction force is equal to the applied force ($F_{f} = F_{a}$) until it reaches the point of maximum static friction. This point is shown on the graph as a **peak**. The point of maximum static friction is determined by the following equation: $F_{f}=\\mu_{s} F_{n}$. As the applied force continues to increase beyond the peak of maximum static friction, the object begins to move. The friction force is now described by the kinetic friction equation: $F_{f}=\\mu_{k} F_{n}$.\n\nMove the slider for the normal force back and forth. As the normal force increases, what happens to the static and kinetic friction forces?\n\n#import ipywidgets as widgets\n\n#Assign each multiple choice to these four variables\n#Option_1 contains the answer\noption_1 = \"The static and kinetic friction forces both increase.\" \noption_2 = \"The static and kinetic friction forces both decrease.\"\noption_3 = \"The static friction force increases and the kinetic friction force decreases.\"\noption_4 = \"The static friction force decreases and the kinetic friction force increases.\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\nMove the slider for the static friction coefficient back and forth. As the static friction coefficient increases, what happens to the static and kinetic friction forces?\n\n#import ipywidgets as widgets\n\n#Assign each multiple choice to these four variables\n#Option_1 contains the answer\noption_1 = \"The static friction force increases and the kinetic friction force remains constant.\" \noption_2 = \"The static friction force decreases and the kinetic friction force remains constant.\"\noption_3 = \"The static friction force increases and the kinetic friction force decreases.\"\noption_4 = \"The static friction force decreases and the kinetic friction force increases.\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\nMove the slider for the kinetic friction coefficient back and forth. As the kinetic friction coefficient increases, what happens to the static and kinetic friction forces?\n\n#import ipywidgets as widgets\n\n#Assign each multiple choice to these four variables\n#Option_1 contains the answer\noption_1 = \"The kinetic friction force increases and the static friction force remains constant.\" \noption_2 = \"The kinetic friction force decreases and the static friction force remains constant.\"\noption_3 = \"The kinetic friction force increases and the static friction force decreases.\"\noption_4 = \"The kinetic friction force decreases and the static friction force increases.\"\n\nmultiple_choice(option_1, option_2, option_3, option_4)\n\n## Conclusions\n\nIn this notebook, the concepts of static and kinetic friction were examined. In summary:\n\n* **Friction** describes the force that resists the relative motion of an object as it slides across a surface. Friction forces are proportional to the normal force:\n\n$$F_{f} = \\mu F_{n}$$\n\n* **Static friction** describes the friction force that acts between an object and the surface to prevent it from sliding. Static friction must be overcome for an object to move.\n\n* **Kinetic friction** describes the friction force that acts between an object and the surface it slides upon. Kinetic friction is used when describing objects in motion.\n\n* **Coefficients of static and kinetic friction** are determined experimentally for different materials. Once determined, these values can be tabulated and used to solve friction problems. An experimental method for determining the coefficients of static and kinetic friction was presented. \n\n* **Friction problems** can be solved using free-body diagrams, the friction formula, and the tabulated values for the coefficients of friction.\n\n* **Force diagrams** can be used to visualize the relationship between the friction force, the applied force, the normal force, and the coefficients of static and kinetic friction.\n\nImages in this notebook represent original artwork.\n\n%%html\n\n<script>\n  function code_toggle() {\n    if (code_shown){\n      $('div.input').hide('500');\n      $('#toggleButton').val('Show Code')\n    } else {\n      $('div.input').show('500');\n      $('#toggleButton').val('Hide Code')\n    }\n    code_shown = !code_shown\n  }\n\n  $( document ).ready(function(){\n    code_shown=false;\n    $('div.input').hide()\n  });\n</script>\n<form action=\"javascript:code_toggle()\"><input type=\"submit\" id=\"toggleButton\" value=\"Show Code\"></form>\n\n[![Callysto.ca License](https://github.com/callysto/curriculum-notebooks/blob/master/callysto-notebook-banner-bottom.jpg?raw=true)](https://github.com/callysto/curriculum-notebooks/blob/master/LICENSE.md)", "meta": {"hexsha": "a636d16142ca612c820ae9c8ab6e1ae65861197b", "size": 29948, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/curriculum-notebooks/Science/StaticAndKineticFriction/static-and-kinetic-friction.py", "max_stars_repo_name": "BryceHaley/curriculum-jbook", "max_stars_repo_head_hexsha": "d1246799ddfe62b0cf5c389394a18c2904383437", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-18T18:19:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T18:19:40.000Z", "max_issues_repo_path": "_build/jupyter_execute/curriculum-notebooks/Science/StaticAndKineticFriction/static-and-kinetic-friction.py", "max_issues_repo_name": "callysto/curriculum-jbook", "max_issues_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/curriculum-notebooks/Science/StaticAndKineticFriction/static-and-kinetic-friction.py", "max_forks_repo_name": "callysto/curriculum-jbook", "max_forks_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 48.6168831169, "max_line_length": 635, "alphanum_fraction": 0.7158407907, "include": true, "reason": "import numpy", "num_tokens": 7244, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.39233683016710835, "lm_q2_score": 0.13477590352179888, "lm_q1q2_score": 0.05287755077065059}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # 14 - Advanced topics - Cement Pavers albedo example\n# \n# This journal creates a paver underneath the single-axis trackers, and evaluates the improvement for one day -- June 17th with and without the pavers for a location in Davis, CA.\n# \n# ![Paver](../images_wiki/AdvancedJournals/Pavers.PNG)\n# \n# Measurements:\n# ![Paver](../images_wiki/AdvancedJournals/Pavers_Geometry.PNG)\n\n# In[1]:\n\n\nimport os\nfrom pathlib import Path\nimport pandas as pd\n\ntestfolder = str(Path().resolve().parent.parent / 'bifacial_radiance' / 'TEMP' / 'Tutorial_14')\nif not os.path.exists(testfolder):\n    os.makedirs(testfolder)\n    \nprint (\"Your simulation will be stored in %s\" % testfolder)\n\n\n# In[2]:\n\n\nfrom bifacial_radiance import *   \nimport numpy as np\n\n\n# In[3]:\n\n\nsimulationname = 'tutorial_14'\n\n#Location:\nlat = 38.5449 # Davis, CA\nlon = -121.7405 # Davis, CA\n# MakeModule Parameters\nmoduletype='test-module'\nnumpanels = 1  # AgriPV site has 3 modules along the y direction (N-S since we are facing it to the south) .\nx = 0.95  \ny = 1.838\nxgap = 0.02# Leaving 2 centimeters between modules on x direction\nygap = 0.0 # 1 - up \nzgap = 0.06 # gap between modules and torquetube.\n\n# Other default values:\n\n# TorqueTube Parameters\naxisofrotationTorqueTube=True\ntorqueTube = False\ncellLevelModule = True\n\nnumcellsx = 6\nnumcellsy = 10\nxcell = 0.156\nycell = 0.158\nxcellgap = 0.015\nycellgap = 0.015\n\nsensorsy = numcellsy   # one sensor per cell\n\ncellLevelModuleParams = {'numcellsx': numcellsx, 'numcellsy':numcellsy, \n                         'xcell': xcell, 'ycell': ycell, 'xcellgap': xcellgap, 'ycellgap': ycellgap}\n\n# SceneDict Parameters\ngcr = 0.33 # m\nalbedo = 0.2  #'grass'     # ground albedo\nhub_height = 1.237 # m  \nnMods = 20 # six modules per row.\nnRows = 3  # 3 row\n\nazimuth_ang = 90 # Facing east \n\n\ndemo = RadianceObj(simulationname,path = testfolder)  # Create a RadianceObj 'object'\ndemo.setGround(albedo) #\nepwfile = demo.getEPW(lat, lon) \nmetdata = demo.readWeatherFile(epwfile, coerce_year=2021) # read in the EPW weather data from above\nmymodule=demo.makeModule(name=moduletype,x=x,y=y,numpanels = numpanels, xgap=xgap, ygap=ygap)\nmymodule.addCellModule(numcellsx=numcellsx, numcellsy=numcellsy,\n                       xcell=xcell, ycell=ycell, xcellgap=xcellgap, ycellgap=ycellgap)\n\n\n# In[4]:\n\n\ndescription = 'Sherman Williams \"Chantilly White\" acrylic paint'\nmaterialpav = 'sw_chantillywhite'\nRrefl = 0.5\nGrefl = 0.5 \nBrefl = 0.5\ndemo.addMaterial(material=materialpav, Rrefl=Rrefl, Grefl=Grefl, Brefl=Brefl, comment=description)\n\n\n# ### Simulation without Pavers\n\n# In[5]:\n\n\ntimeindex = metdata.datetime.index(pd.to_datetime('2021-06-17 12:0:0 -8'))  # Davis, CA is TZ -8\ndemo.gendaylit(timeindex)  \n    \ntilt = demo.getSingleTimestampTrackerAngle(metdata, timeindex=timeindex, gcr=gcr, \n                                   azimuth=180, axis_tilt=0, \n                                   limit_angle=60, backtrack=True)\n# create a scene with all the variables\nsceneDict = {'tilt':tilt,'gcr': gcr,'hub_height':hub_height,'azimuth':azimuth_ang, 'module_type':moduletype, 'nMods': nMods, 'nRows': nRows}  \nscene = demo.makeScene(module=mymodule, sceneDict=sceneDict) #makeScene creates a .rad file with 20 modules per row, 7 rows.\noctfile = demo.makeOct(demo.getfilelist())  # makeOct combines all of the ground, sky and object fil|es into a .oct file.\n\n\n# In[6]:\n\n\nanalysis = AnalysisObj(octfile, demo.name)  # return an analysis object including the scan dimensions for back irradiance\nfrontscan, backscan = analysis.moduleAnalysis(scene, sensorsy=sensorsy)\nanalysis.analysis(octfile, simulationname+\"_noPavers\", frontscan, backscan)  # compare the back vs front irradiance  \nprint(\"Simulation without Pavers Finished\")\n\n\n# ## Looping on the day\n\n# In[7]:\n\n\nj=0\nstarttimeindex = metdata.datetime.index(pd.to_datetime('2021-06-17 7:0:0 -8'))\nendtimeindex = metdata.datetime.index(pd.to_datetime('2021-06-17 19:0:0 -8'))\nfor timess in range (starttimeindex, endtimeindex):\n    j+=1\n    demo.gendaylit(timess)\n    tilt = demo.getSingleTimestampTrackerAngle(metdata, timeindex=timess, gcr=gcr, \n                                       azimuth=180, axis_tilt=0, \n                                       limit_angle=60, backtrack=True)\n    # create a scene with all the variables\n    sceneDict = {'tilt':tilt,'gcr': gcr,'hub_height':hub_height,'azimuth':azimuth_ang, 'module_type':moduletype, 'nMods': nMods, 'nRows': nRows}  \n    scene = demo.makeScene(module=mymodule, sceneDict=sceneDict) #makeScene creates a .rad file with 20 modules per row, 7 rows.\n    octfile = demo.makeOct(demo.getfilelist())  # makeOct combines all of the ground, sky and object fil|es into a .oct file\n    frontscan, backscan = analysis.moduleAnalysis(scene, sensorsy=sensorsy)\n    analysis.analysis(octfile, simulationname+\"_noPavers_\"+str(j), frontscan, backscan)  # compare the back vs front irradiance  \n    \n\n\n# ### Simulation With Pavers\n\n# In[8]:\n\n\ndemo.gendaylit(timeindex)\ntilt = demo.getSingleTimestampTrackerAngle(metdata, timeindex=timeindex, gcr=gcr, \n                                   azimuth=180, axis_tilt=0, \n                                   limit_angle=60, backtrack=True)\n# create a scene with all the variables\nsceneDict = {'tilt':tilt,'gcr': gcr,'hub_height':hub_height,'azimuth':azimuth_ang, 'module_type':moduletype, 'nMods': nMods, 'nRows': nRows}  \nscene = demo.makeScene(module=mymodule, sceneDict=sceneDict) #makeScene creates a .rad file with 20 modules per row, 7 rows.\n\n\n# In[9]:\n\n\ntorquetubelength = demo.module.scenex*(nMods) \npitch = demo.module.sceney/gcr\nstartpitch = -pitch * (nRows-1)/2\np_w = 0.947 # m\np_h = 0.092 # m\np_w2 = 0.187 # m\np_h2 = 0.184 # m\noffset_w1y = -(p_w/2)+(p_w2/2)\noffset_w2y = (p_w/2)-(p_w2/2)\n\ncustomObjects = []\nfor i in range (0, nRows):    \n    name='PAVER'+str(i)\n    text='! genbox {} paver{} {} {} {} | xform -t {} {} 0 | xform -t {} 0 0'.format(materialpav, i, \n                                    p_w, torquetubelength, p_h, \n                                    -p_w/2, (-torquetubelength+demo.module.sceney)/2.0,\n                                    startpitch+pitch*i)\n    text += '\\r\\n! genbox {} paverS1{} {} {} {} | xform -t {} {} 0 | xform -t {} 0 0'.format(materialpav, i,\n                                    p_w2, torquetubelength, p_h2, \n                                    -p_w2/2+offset_w1y, (-torquetubelength+demo.module.sceney)/2.0,\n                                    startpitch+pitch*i)\n    text += '\\r\\n! genbox {} paverS2{} {} {} {} | xform -t {} {} 0 | xform -t {} 0 0'.format(materialpav, i,\n                                    p_w2, torquetubelength, p_h2, \n                                    -p_w2/2+offset_w2y, (-torquetubelength+demo.module.sceney)/2.0,\n                                    startpitch+pitch*i)\n\n    customObject = demo.makeCustomObject(name,text)\n    customObjects.append(customObject)\n    demo.appendtoScene(radfile=scene.radfiles, customObject=customObject, text=\"!xform -rz 0\")\n\n\n# In[10]:\n\n\ndemo.makeOct()\n\n\n# You can view the geometry generated in the terminal with:\n# \n# ### rvu -vf views\\front.vp -e .01 -pe 0.01 -vp -5 -14 1 -vd 0 0.9946 -0.1040 tutorial_14.oct\n\n# In[11]:\n\n\n\n## Comment the ! line below to run rvu from the Jupyter notebook instead of your terminal.\n## Simulation will stop until you close the rvu window\n\n#!rvu -vf views\\front.vp -e .01 -pe 0.01 -vp -5 -14 1 -vd 0 0.9946 -0.1040 tutorial_14.oct\n\n\n# In[12]:\n\n\nanalysis = AnalysisObj(octfile, demo.name)  # return an analysis object including the scan dimensions for back irradiance\nfrontscan, backscan = analysis.moduleAnalysis(scene, sensorsy=sensorsy)\nanalysis.analysis(octfile, simulationname+\"_WITHPavers\", frontscan, backscan)  # compare the back vs front irradiance  \nprint(\"Simulation WITH Pavers Finished\")\n\n\n# ## LOOP WITH PAVERS\n\n# In[13]:\n\n\nj=0\nfor timess in range (starttimeindex, endtimeindex):\n    j+=1\n    demo.gendaylit(timess)\n    tilt = demo.getSingleTimestampTrackerAngle(metdata, timeindex=timess, gcr=gcr, \n                                       azimuth=180, axis_tilt=0, \n                                       limit_angle=60, backtrack=True)\n    # create a scene with all the variables\n    sceneDict = {'tilt':tilt,'gcr': gcr,'hub_height':hub_height,'azimuth':azimuth_ang, 'module_type':moduletype, 'nMods': nMods, 'nRows': nRows}  \n    scene = demo.makeScene(mymodule, sceneDict=sceneDict) #makeScene creates a .rad file with 20 modules per row, 7 rows.\n    # Appending Pavers here\n    demo.appendtoScene(radfile=scene.radfiles, customObject=customObjects[0], text=\"!xform -rz 0\")\n    demo.appendtoScene(radfile=scene.radfiles, customObject=customObjects[1], text=\"!xform -rz 0\")\n    demo.appendtoScene(radfile=scene.radfiles, customObject=customObjects[2], text=\"!xform -rz 0\")\n    octfile = demo.makeOct(demo.getfilelist())  # makeOct combines all of the ground, sky and object fil|es into a .oct file\n    frontscan, backscan = analysis.moduleAnalysis(scene, sensorsy=sensorsy)\n    analysis.analysis(octfile, simulationname+\"_WITHPavers_\"+str(j), frontscan, backscan)  # compare the back vs front irradiance  \n    \n\n\n# # RESULTS ANALYSIS NOON\n\n# In[14]:\n\n\ndf_0 = load.read1Result(os.path.join(testfolder, 'results', 'irr_tutorial_14_noPavers.csv'))\ndf_w = load.read1Result(os.path.join(testfolder, 'results', 'irr_tutorial_14_WITHPavers.csv'))                        \n\n\n# In[15]:\n\n\ndf_0\n\n\n# In[16]:\n\n\ndf_w\n\n\n# ## Improvement in Rear Irradiance\n\n# In[17]:\n\n\nround((df_w['Wm2Back'].mean()-df_0['Wm2Back'].mean())*100/df_0['Wm2Back'].mean(),1)\n\n\n# # RESULT ANALYSIS DAY\n\n# In[18]:\n\n\ndf_0 = load.read1Result(os.path.join(testfolder, 'results', 'irr_tutorial_14_noPavers_1.csv'))\ndf_w = load.read1Result(os.path.join(testfolder, 'results', 'irr_tutorial_14_WITHPavers_1.csv'))\n\n\n# In[19]:\n\n\ndf_w\n\n\n# In[20]:\n\n\ndf_0\n\n\n# In[21]:\n\n\nround((df_w['Wm2Back'].mean()-df_0['Wm2Back'].mean())*100/df_0['Wm2Back'].mean(),1)\n\n\n# In[22]:\n\n\naverage_back_d0=[]\naverage_back_dw=[]\naverage_front = []\nhourly_rearirradiance_comparison = []\n\ntimessimulated = endtimeindex-starttimeindex\n\nfor i in range (1, timessimulated+1):\n    df_0 = load.read1Result(os.path.join(testfolder, 'results', 'irr_tutorial_14_noPavers_'+str(i)+'.csv'))\n    df_w = load.read1Result(os.path.join(testfolder, 'results', 'irr_tutorial_14_WITHPavers_'+str(i)+'.csv'))\n    print(round((df_w['Wm2Back'].mean()-df_0['Wm2Back'].mean())*100/df_0['Wm2Back'].mean(),1))\n    hourly_rearirradiance_comparison.append(round((df_w['Wm2Back'].mean()-df_0['Wm2Back'].mean())*100/df_0['Wm2Back'].mean(),1))\n    average_back_d0.append(df_0['Wm2Back'].mean())\n    average_back_dw.append(df_w['Wm2Back'].mean())\n    average_front.append(df_0['Wm2Front'].mean())\n    \n\n\n# In[23]:\n\n\nprint(\"Increase in rear irradiance: \", round((sum(average_back_dw)-sum(average_back_d0))*100/sum(average_back_d0),1))\n\n\n# In[24]:\n\n\nprint(\"BG no Pavers: \", round(sum(average_back_d0)*100/sum(average_front),1))\nprint(\"BG with Pavers: \", round(sum(average_back_dw)*100/sum(average_front),1))\n\n\n# In[27]:\n\n\nimport matplotlib.pyplot as plt\n\n#metdata.datetime[starttime].hour # 7\n#metdata.datetime[endtimeindex].hour # 17\nxax= [7, 8, 9, 10, 11, 12,13,14,15,16,17,18]  # Lazy way to get the x axis...\n\n\n# In[28]:\n\n\nplt.plot(xax,hourly_rearirradiance_comparison)\nplt.ylabel('$\\Delta$ in G$_{rear}$ [%] \\n(G$_{rear-with}$ - G$_{rear-without}$ / G$_{rear-without}$)')\nplt.xlabel('Hour')\n\n", "meta": {"hexsha": "e98bd2f805b3ec049cd9b7bf87af9b10d21f38c1", "size": 11415, "ext": "py", "lang": "Python", "max_stars_repo_path": "docs/tutorials/14 - Advanced topics - Cement Pavers albedo example.py", "max_stars_repo_name": "kperrynrel/bifacial_radiance", "max_stars_repo_head_hexsha": "cf5ae46b4ef93990e3e1619956a186376cb4fd8a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "docs/tutorials/14 - Advanced topics - Cement Pavers albedo example.py", "max_issues_repo_name": "kperrynrel/bifacial_radiance", "max_issues_repo_head_hexsha": "cf5ae46b4ef93990e3e1619956a186376cb4fd8a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/tutorials/14 - Advanced topics - Cement Pavers albedo example.py", "max_forks_repo_name": "kperrynrel/bifacial_radiance", "max_forks_repo_head_hexsha": "cf5ae46b4ef93990e3e1619956a186376cb4fd8a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.8854748603, "max_line_length": 179, "alphanum_fraction": 0.6727113447, "include": true, "reason": "import numpy", "num_tokens": 3476, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3812195662561499, "lm_q2_score": 0.1384617870138417, "lm_q1q2_score": 0.052784342388468145}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# ---\n# title: ERP Core N400 in MNE-Python: part III\n# date: 2021-04-23\n# image:\n#   preview_only: true\n# tags: \n# - Python\n# - EEG\n# - Preprocessing\n# categories:\n# - Python\n# - EEG\n# - English\n# summary: \"Adapting ICA artifact rejection.\"\n# copyright_license:\n#   enable: true\n#   \n# ---\n\n# In the [last post](https://msilvestrin.me/post/n400_2/) on adapting ERP CORE's N400 pipeline to MNE-Python, we did the ICA-related steps to correct blinking and horizontal eye-movement artfacts from the signal. Here we do some final steps in cleaning the data: interpolation of bad channels, epoching and rejection of epochs with possible artifacts. These steps are decipted in the  _Elist_Bin_Epoch_ script of ERP CORE resources (script 5). \n# \n# Contrary to previous posts, I won't make the whole process in a single participant and show the loop for all participants at the end. That is because the result for some af the steps are saved as intermediate stages of the preprocessing pipeline. I should also tell you up-front that I wasn't able to find implemented equivalents for some of the procedures ERP CORE uses to define artifacts. That forced me to implement a python version of what they do. Therefore, this post is a little longer the the other ones, so buckle up! On the bright side, at the end we will have the data ready to start looking for those N400 ERPs. \n# \n\n# ## Interpolation\n# Our first step here is to interpolate bad channels. Bad channels for each participant are listed in the file \"Interpolate_Channels_N400.xlsx\" provided by ERP CORE. Below, I load the information in that file, make a list of bad channels for each participant and add that list to their `raw.info['bads']`.\n# \n# Load the information:\n\n# In[3]:\n\n\nimport os\nos.chdir('D:\\\\EEGdata\\\\Erp CORE\\\\N400')\n\nimport mne\n# import some methods directly so we can call them by name\nfrom mne.io import read_raw\nfrom mne.epochs import read_epochs\n\nimport numpy as np\nimport pandas as pd\n\nget_ipython().run_line_magic('matplotlib', 'qt')\nget_ipython().run_line_magic('gui', 'qt')\n\n\n# In[8]:\n\n\n# load as DataFrame\ninterpolate_path = \"D:\\\\EEGdata\\\\Erp CORE\\\\N400\\\\EEG_ERP_Processing\\\\Interpolate_Channels_N400.xlsx\"\nchans_interpolate = pd.read_excel(interpolate_path)\n# Turn strings to a list of strings for each participant\nchans_interpolate = chans_interpolate.loc[:,\"Name of Interpolated Channel\"].str.split(\" \")\n\n\n# Now I'll deal with some nuisences in the file: there is an asterisk at the beginning of the channel list for each participant, and Fp channels are in upper-case. We remove the asterisk and correct the captalization.\n\n# In[11]:\n\n\n# make function to remove asterisk and correct \ndef remove_star(item):\n    # if item is a list\n    if isinstance(item, list):\n        # if list is longer than 1\n        if len(item) > 1:\n            # remove asterisk\n            clean_names = [item[0].lstrip(\"*\")]\n            # add channel to a list clean_names\n            clean_names.extend(item[1:])\n            # look for Fp channels and correct captalization\n            for n, elec in enumerate(clean_names):\n                if elec =='FP1' or elec =='FP2':\n                    clean_names[n] = elec.capitalize() \n        else:\n            clean_names = [item[0].lstrip(\"*\")]\n            if clean_names[0] =='FP1' or clean_names[0] =='FP2':\n                clean_names[0] = clean_names[0].capitalize()\n    else:\n        clean_names = np.nan\n    return clean_names\n        \n# apply function \nchans_interpolate = chans_interpolate.apply(remove_star)\nchans_interpolate.loc[chans_interpolate.notnull()].head()\n\n\n# We have already indentified the channels to be interpolated, however if we try to do the interpolation now MNE will throw us an error because we have more EEG channels than mapped on the 3D digitation. The channels HEOG_left, HEOG_right and VEOG_lower are currently identified as EEG channels, but they are actually extra channels we used to make the proper HEOG and VEOG channels. We will drop them, since they already served their purpose.\n# \n# Let's do it for all participants and save an intermediate (\"interpol\") raw file:\n\n# In[ ]:\n\n\nfor subj in range(1,41):\n    raw_correct_path = \"D:\\\\EEGdata\\\\Erp CORE\\\\N400\\\\mne\\\\raw_corrected\\\\N400_ERP_CORE_{}_correct-raw.fif\".format(subj)\n    raw_correct = read_raw(raw_correct_path, preload = True)\n    #only do interpolation if there is at least one channel to interpolate\n    if  not chans_interpolate.isna()[subj-1]:\n        raw_correct.info['bads'].extend(chans_interpolate[subj-1])\n        # drop extra channels\n        raw_correct.drop_channels(['HEOG_left', 'HEOG_right', 'VEOG_lower'])\n        raw_correct.interpolate_bads()\n    else:\n        raw_correct.drop_channels(['HEOG_left', 'HEOG_right', 'VEOG_lower'])\n    \n    interpol_path = \"D:\\\\EEGdata\\\\Erp CORE\\\\N400\\\\mne\\\\raw_interpol\\\\N400_ERP_CORE_{}_interpol-raw.fif\".format(subj)\n    raw_correct.save(interpol_path, overwrite=True)\n\n\n# ## Event list for epochs\n# Now let's make our event list and event_ids for epoching.\n# \n# As we did at the back at beginning of preprocessing [(in this post)](https://msilvestrin.me/post/n400_1/), we will get the events from the `annotations` in the data. Until now, we have two types of annotation descriptions in the data: \"BAD_seg\" and numbers corresponding to triggers used in the experiment. The ERP CORE file \"N400_Event_Code_Scheme.xlsx\" has the meaning for each code. For instance, the code 121 refers to a Priming stimuli which is unrelated to the target stimulus and comes from the second list of words; while the code 201 means that the participant gave a correct answer.\n# \n# We are going to change these codes to a descriptive account of each event. A nice feature of MNE is that we can make _hierarchical ids_. We will follow the hierarchy shown in the N400_Event_Code_Scheme file: Word Type > Relatedness > Word List.\n# \n# First, we will create a dictionary with the correspondence between codes and events to properly identify them later. We will be able to use these ids to select epochs afterwards.\n\n# In[ ]:\n\n\n# load data\nsubj = 1\ninterpol_path = \"D:\\\\EEGdata\\\\Erp CORE\\\\N400\\\\mne\\\\raw_interpol\\\\N400_ERP_CORE_{}_interpol-raw.fif\".format(subj)\nraw_interpol = read_raw(interpol_path)\n# make dict with correspondences between codes and hierarchical ids\ndescription_dict = {'111' : 'Prime/Related/L1',\n             '112' : 'Prime/Related/L2',\n             '121' : 'Prime/Unrelated/L1',\n             '122' : 'Prime/Unrelated/L2',\n             '211' : 'Target/Related/L1',\n             '212' : 'Target/Related/L2',\n             '221' : 'Target/Unrelated/L1',\n             '222' : 'Target/Unrelated/L2',\n             '201' : 'Hit',\n             '202' : 'Miss',\n             'BAD_seg': 'BAD_seg'      \n                   }\n\n\n# We will change the description list with some [Pandas](https://pandas.pydata.org/) functionality. It is beyond this tutorial to teach Pandas' skills, but it is nice for you to know that, although most of the backbone of MNE is in [Numpy](https://numpy.org/), it also allows exportation to Pandas' data structures.\n# \n# In summary, what we do in the one-liner below is make a copy of the annotations descriptions while transforming it to a Pandas series, then we make the substituitions according to our `description dictionary` and turn it back to a numpy array.\n\n# In[ ]:\n\n\nraw_interpol.annotations.description = pd.Series(raw_interpol.annotations.description).map(description_dict).to_numpy()\n# substitute annotations description\nset(raw_interpol.annotations.description)\n\n\n# Now we are almost ready to make the `events` numpy array we will need to epoch the data. We will use the `events_from_annotations` function. One last step before that: create a dictionary with correspondences between hierarchical ids and trigger numbers.\n# \n# You may be wondering why we would do that when we just made the reverse dictionary on our last step. The thing is that MNE's event list is a _numeric array_ composed of columns _instant_, _blank column_ and _event code_, and the default behavior of `events_from_annotations` is to assign the event codes as \\[0,1,2,3...\\]. However, I want to keep the original codes from ERP CORE, so I need to use the `events_id` input with a dict showing the correspondences. I should say that for the rest of our MNE operations the numeric codes themselves are actually rather irrelevant, what really matters are the correspondences in `event_ids`. I am just being picky to keep as close as possible to the original ERP CORE material.\n\n# In[ ]:\n\n\nevent_ids = {'Prime/Related/L1': 111,\n             'Prime/Related/L2': 112,\n             'Prime/Unrelated/L1' : 121,\n             'Prime/Unrelated/L2' : 122,\n             'Target/Related/L1' : 211,\n             'Target/Related/L2' : 212,\n             'Target/Unrelated/L1' : 221,\n             'Target/Unrelated/L2' : 222,\n             'Hit' : 201,\n             'Miss' : 202}\nevents, event_ids = mne.events_from_annotations(raw_interpol, event_ids)\n\n\n# So, our events look like this (_instant_, _blank column_, _event code_):\n\n# In[7]:\n\n\nevents\n\n\n# ## Epoching and artfact rejection\n# The ERP CORE pipeline is __very throrough__ in its epoch dropping due to ocular artifact detection. There are different thresholds for epoch dropping for: (1) EEG channels, (2) the VEOG channel and (3 and 4) for both variations of the HEOG channel (with and without ICA applied). In MNE, we can set epoch rejection thresholds for each channel type by setting the `reject` input when we create the epochs.\n# \n# However, as far as I understand from the documentation, MNE uses a simple peak-to-peak algorithm to do its automatic rejection. ERP CORE pipeline uses such an algorithm only for rejection on the scalp EEG channels. For VEOG and uncorrected HEOG channels it uses a windowed peak-to-peak algorithm and for ICA corrected HEOG it uses a step algorithm (both as implemented in the ERP LAB toolbox).\n# \n# Since ERP CORE gives us the parameters, and the algorithms themselves are quite straightforward, I have implemented them below. I make use of the nifty feature of MNE that allows us to loop through epochs. On each epoch I run the algorithms on the corresponding channels and, if some amplitude is above the threshold, it is marked as bad with a `MW_Reject` annotation. The value compared to the treshold on each algorithm are the following:\n# \n# * Step algorithm: $\\bmod (mean(window1)-mean(window2))$\n# * Peak-to-peak algorithm: $\\bmod (max(window1)-min(window2))$\n# \n# Below, we (1) load the the information we need for the artfact rejection procedure, (2) create the dictionaries we need for marking the events in the experiment (as shown above); then, in the loop, we (3) add the annotations for epoching, (4) do the epoching with `mne.Epochs()`, (5) run the artfact rejection algorithm and (6) save the epochs.\n\n# In[ ]:\n\n\n#get eog channels numbers\nsubj = 1\ninterpol_path = \"D:\\\\EEGdata\\\\Erp CORE\\\\N400\\\\mne\\\\raw_interpol\\\\N400_ERP_CORE_{}_interpol-raw.fif\".format(subj)\nraw_interpol = read_raw(interpol_path)\neog_nums = [np.where(np.array(raw_interpol.ch_names) == 'VEOG')[0].item(0),\n            np.where(np.array(raw_interpol.ch_names) == 'HEOG')[0].item(0),\n            np.where(np.array(raw_interpol.ch_names) == 'HEOG_ICA')[0].item(0)]\n\n#get veog moving windows parameters from files\nveog_path = \"D:\\\\EEGdata\\\\Erp CORE\\\\N400\\\\EEG_ERP_Processing\\\\AR_Parameters_for_MW_CRAP_N400.xlsx\"\nveog_mw_params = pd.read_excel(veog_path)\n#convert time columns to seconds\nveog_mw_params.iloc[:,3:] = veog_mw_params.iloc[:,3:].apply(lambda x: x*1e-3)\n#convert threshold to volts\nveog_mw_params.Threshold = veog_mw_params.Threshold*1e-4\n\n# the same for non ICA corrected heog moving windows\nheog_path = \"D:\\\\EEGdata\\\\Erp CORE\\\\N400\\\\EEG_ERP_Processing\\\\AR_Parameters_for_MW_Blinks_N400.xlsx\"\nheog_mw_params = pd.read_excel(heog_path)\nheog_mw_params.iloc[:,3:] = heog_mw_params.iloc[:,3:].apply(lambda x: x*1e-3)\nheog_mw_params.Threshold = heog_mw_params.Threshold*1e-4\n\n#... and for ICA corrected HEOG moving windows\nheog_ica_path = \"D:\\\\EEGdata\\\\Erp CORE\\\\N400\\\\EEG_ERP_Processing\\\\AR_Parameters_for_SL_HEOG_N400.xlsx\"\nheog_ica_mw_params = pd.read_excel(heog_ica_path)\nheog_ica_mw_params.iloc[:,3:] = heog_ica_mw_params.iloc[:,3:].apply(lambda x: x*1e-3)\nheog_ica_mw_params.Threshold = heog_ica_mw_params.Threshold*1e-4\n\n#put moving windows dfs in a list\nmw_params = [veog_mw_params, heog_mw_params, heog_ica_mw_params]\n\n# make dict with correspondences between codes and hierarchical ids\ndescription_dict = {'111' : 'Prime/Related/L1',\n                    '112' : 'Prime/Related/L2',\n                    '121' : 'Prime/Unrelated/L1',\n                    '122' : 'Prime/Unrelated/L2',\n                    '211' : 'Target/Related/L1',\n                    '212' : 'Target/Related/L2',\n                    '221' : 'Target/Unrelated/L1',\n                    '222' : 'Target/Unrelated/L2',\n                    '201' : 'Hit',\n                    '202' : 'Miss',\n                    'BAD_seg': 'BAD_seg'      \n               }\n\n #create correspondence between description and trigger number\nevent_ids = {'Prime/Related/L1': 111,\n             'Prime/Related/L2': 112,\n             'Prime/Unrelated/L1' : 121,\n             'Prime/Unrelated/L2' : 122,\n             'Target/Related/L1' : 211,\n             'Target/Related/L2' : 212,\n             'Target/Unrelated/L1' : 221,\n             'Target/Unrelated/L2' : 222,\n             'Hit' : 201,\n             'Miss' : 202}\n\n# loop\nfor subj in range(1,41):\n    interpol_path = \"D:\\\\EEGdata\\\\Erp CORE\\\\N400\\\\mne\\\\raw_interpol\\\\N400_ERP_CORE_{}_interpol-raw.fif\".format(subj)\n    raw_interpol = read_raw(interpol_path)\n\n    #add event descriptions to annotations\n    raw_interpol.annotations.description = pd.Series(raw_interpol.annotations.description).map(description_dict).to_numpy()\n    set(raw_interpol.annotations.description)\n   \n    #create events and event ids\n    events, event_ids = mne.events_from_annotations(raw_interpol, event_ids)\n    \n    #change heog channel types\n    raw_interpol.set_channel_types({'HEOG_ICA':'emg', 'HEOG':'misc'})\n    epochs = mne.Epochs(raw_interpol, \n                        events,\n                        event_ids,\n                        baseline = (-.2,0),\n                        tmax = .8,\n                        reject = dict(eeg  = 200e-6)\n                       )\n    \n    epos_to_drop = []\n    # run through every epoch\n    for i in range(len(epochs.events)):\n        # for each channel of interest\n        for eog_chan_num, mw_df in zip(eog_nums, mw_params): #\n            # get moving windows parameters\n                w_size = mw_df['Window Size'].iloc[subj-1]\n                w_start = mw_df['Time Window Minimum'].iloc[subj-1].round(2)\n                w_start_last = np.round(mw_df['Time Window Maximum'].iloc[subj-1] - mw_df['Window Size'].iloc[subj-1],2)\n                w_stop = mw_df['Time Window Maximum'].iloc[subj-1].round(2)\n                w_stop_first = np.round(w_start + w_size,2)\n               # create an array with starting and stopping times of every window\n                mw_starts = np.arange(w_start,\n                                      w_start_last,\n                                      w_size)\n                mw_stops = np.arange(w_stop_first,\n                                     w_stop,\n                                     w_size)\n        # only run if channel is not empty, e.g. already marked as bad\n            if epochs[i].get_data()[:,eog_chan_num,:].shape[0] != 0:\n                #get channel data\n                chan_data = epochs[i].get_data()[:,eog_chan_num,:].flatten()\n                #make list with data for each window\n                mws = [ chan_data[epochs.time_as_index(start).item(0) : epochs.time_as_index(stop).item(0)] for start, stop in zip(mw_starts, mw_stops)]\n\n               # if channel is veog or uncorrected heog do peak-to-peak artfact detection\n                if eog_chan_num < 32:\n                    mws = pd.DataFrame(mws).T\n                    peak2peak = mws.apply(lambda x: np.abs(x.max() - x.min()))\n                    if any(peak2peak > mw_df['Threshold'].iloc[subj-1]):\n                        epos_to_drop.append(i)\n                # if channel is heog_ica do step artfact detection\n                else:\n                    steps = [True for i in range(len(mws)-1) if np.abs(mws[i].mean()-mws[i+1].mean()) > mw_df['Threshold'].iloc[subj-1]] \n                    if steps:\n                        epos_to_drop.append(i)\n    # if any epoch was set as bad add it to drop list with label MW Reject\n    if epos_to_drop: \n        epochs.drop(epos_to_drop,'MW_Reject')\n    #Save epochs                        \n    epochs_path = \"D:\\\\EEGdata\\\\Erp CORE\\\\N400\\\\mne\\\\epochs\\\\N400_ERP_CORE_{}-epo.fif\".format(subj)\n    print('Subject {}'.format(subj)) # line to keep up with analysis as it runs\n    epochs.save(epochs_path, overwrite=True)\n\n\n# Lastly, let's check the percentage of dropped epochs for each participant.\n\n# In[ ]:\n\n\npercent_dropped = pd.DataFrame(data = {'Subj': np.repeat(np.nan, 40),\n                                       'Dropped': np.repeat(np.nan, 40)}) \nfor subj in range(1,41):\n    epochs_path = \"D:\\\\EEGdata\\\\Erp CORE\\\\N400\\\\mne\\\\epochs\\\\N400_ERP_CORE_{}-epo.fif\".format(subj)\n    epochs = read_epochs(epochs_path)\n\n    percent_dropped['Subj'].iloc[subj-1] = subj\n    percent_dropped['Dropped'].iloc[subj-1] = np.round(epochs.drop_log_stats(),2)\n\n\n# In[6]:\n\n\npercent_dropped['Dropped'].describe().round(2)\n\n\n# Dropped epochs per participant range from roughly 4% to 85%. Here, we will set consider participants with more than 30% of epochs dropped as participants with too many artfacts to be used. The ones that do not pass this filter are below:\n\n# In[7]:\n\n\nbad_subjs = percent_dropped.loc[percent_dropped.Dropped >30].Subj\nbad_subjs.to_csv('bad_subjs.csv')\nbad_subjs.count()\n\n\n# We have 5 unsuable participants. This is different from ERP CORE's original preprocessing results, where they lose a single participant. However, I wasn't able to exactly reproduce the ICA step in the pipeline, so that is probably where we are falling a little behind. Anyway, 35 participants are more than enough for us to grasp the N400 effects in the following analyses. So, enough preprocesing, let's get to those ERPs in the next post!\n# \n# Let's finish contemplating some hard earned epochs:\n\n# In[12]:\n\n\nepochs.plot(n_epochs = 4)\n\n", "meta": {"hexsha": "f0e4d64564868af16c9d463407349e9a56ca5aae", "size": 18469, "ext": "py", "lang": "Python", "max_stars_repo_path": "N400_ERP_CORE_3.py", "max_stars_repo_name": "MateusPsi/erp-Core-N400", "max_stars_repo_head_hexsha": "7c2a44087a148a3b7a395cbeec09753d7ff59ece", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-06T03:37:41.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-06T03:37:41.000Z", "max_issues_repo_path": "N400_ERP_CORE_3.py", "max_issues_repo_name": "MateusPsi/erp-Core-N400", "max_issues_repo_head_hexsha": "7c2a44087a148a3b7a395cbeec09753d7ff59ece", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "N400_ERP_CORE_3.py", "max_forks_repo_name": "MateusPsi/erp-Core-N400", "max_forks_repo_head_hexsha": "7c2a44087a148a3b7a395cbeec09753d7ff59ece", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 50.4617486339, "max_line_length": 722, "alphanum_fraction": 0.6809247929, "include": true, "reason": "import numpy", "num_tokens": 4732, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4073334000459302, "lm_q2_score": 0.12940274334274965, "lm_q1q2_score": 0.052710059421073076}}
{"text": "# To add a new cell, type '#%%'\n# To add a new markdown cell, type '#%% [markdown]'\n#%% Change working directory from the workspace root to the ipynb file location. Turn this addition off with the DataScience.changeDirOnImportExport setting\n# ms-python.python added\nimport os\ntry:\n\tos.chdir(os.path.join(os.getcwd(), 'notebooks'))\n\tprint(os.getcwd())\nexcept:\n\tpass\n#%%\nfrom IPython import get_ipython\n\n#%% [markdown]\n# <a href=\"https://colab.research.google.com/github/KyleHaggin/DnD-class-predictor/blob/master/Models_and_Work.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n#%% [markdown]\n# Lambda School Data Science, Unit 2: Predictive Modeling\n# \n# # Applied Modeling, Module 2\n# \n# You will use your portfolio project dataset for all assignments this sprint.\n# \n# ## Assignment\n# \n# Complete these tasks for your project, and document your work.\n# \n# - [ ] Plot the distribution of your target. \n#     - Classification problem: Are your classes imbalanced? Then, don't use just accuracy.\n#     - Regression problem: Is your target skewed? If so, let's discuss in Slack.\n# - [ ] Continue to clean and explore your data. Make exploratory visualizations.\n# - [ ] Fit a model. Does it beat your baseline?\n# - [ ] Try xgboost.\n# - [ ] Get your model's permutation importances.\n# \n# You should try to complete an initial model today, because the rest of the week, we're making model interpretation visualizations.\n# \n# \n# ## Reading\n# \n# Top recommendations in _**bold italic:**_\n# \n# #### Permutation Importances\n# - _**[Kaggle / Dan Becker: Machine Learning Explainability](https://www.kaggle.com/dansbecker/permutation-importance)**_\n# - [Christoph Molnar: Interpretable Machine Learning](https://christophm.github.io/interpretable-ml-book/feature-importance.html)\n# \n# #### (Default) Feature Importances\n#   - [Ando Saabas: Selecting good features, Part 3, Random Forests](https://blog.datadive.net/selecting-good-features-part-iii-random-forests/)\n#   - [Terence Parr, et al: Beware Default Random Forest Importances](https://explained.ai/rf-importance/index.html)\n# \n# #### Gradient Boosting\n#   - [A Gentle Introduction to the Gradient Boosting Algorithm for Machine Learning](https://machinelearningmastery.com/gentle-introduction-gradient-boosting-algorithm-machine-learning/)\n#   - _**[A Kaggle Master Explains Gradient Boosting](http://blog.kaggle.com/2017/01/23/a-kaggle-master-explains-gradient-boosting/)**_\n#   - [_An Introduction to Statistical Learning_](http://www-bcf.usc.edu/~gareth/ISL/ISLR%20Seventh%20Printing.pdf) Chapter 8\n#   - [Gradient Boosting Explained](http://arogozhnikov.github.io/2016/06/24/gradient_boosting_explained.html)\n#   - _**[Boosting](https://www.youtube.com/watch?v=GM3CDQfQ4sw) (2.5 minute video)**_\n\n#%%\nimport os, sys\nin_colab = 'google.colab' in sys.modules\n\n# If you're in Colab...\nif in_colab:\n    # Pull files from Github repo\n    os.chdir('/content')\n    get_ipython().system('git init .')\n    get_ipython().system('git remote add origin https://github.com/LambdaSchool/DS-Unit-2-Applied-Modeling.git')\n    get_ipython().system('git pull origin master')\n    # Install packages in Colab\n    get_ipython().system('pip install category_encoders==2.0.0')\n    get_ipython().system('pip install eli5==0.10.1')\n    get_ipython().system('pip install pandas-profiling==2.3.0')\n    get_ipython().system('pip install pdpbox==0.2.0')\n    get_ipython().system('pip install plotly==4.1.1')\n    get_ipython().system('pip install shap==0.30.0')\n    \n    # Install required python packages\n    get_ipython().system('pip install -r requirements.txt')\n    \n    # Change into directory for module\n    os.chdir('module2')\n\n\n#%%\n# import important libraries\nimport numpy as np\nimport pandas as pd\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.model_selection import train_test_split\nimport category_encoders as ce \nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.impute import SimpleImputer\nfrom sklearn.pipeline import make_pipeline\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.metrics import confusion_matrix\nfrom xgboost import XGBClassifier\nfrom sklearn.metrics import roc_auc_score\nimport eli5\nfrom eli5.sklearn import PermutationImportance\n\n\n#%%\n# import the dataset\ndf = pd.read_csv('https://raw.githubusercontent.com/oganm/dndstats/master/docs/uniqueTable.tsv',\n                 sep='\\t')\n\n\n#%%\n# double check the import worked correctly\ndf.head()\n\n\n#%%\n# create a has spells feature\n\n# create a function that returns true if there is a spell or false if there is not\ndef check_spells(item):\n  # check if the value is a float. This works because np.nan is a float value and the value will be a string if there are spells\n  if isinstance(item, float):\n    # if nan is found return false (no spells)\n    return False\n  else:\n    # else return true (spell found)\n    return True\n\n# apply the function to the dataframe\ndf['has_spells'] = df['processedSpells'].apply(check_spells)\n\n\n#%%\ndf.head()\n\n\n#%%\n# create a has feat feature\n\n# create a function that returns true if it has a feat and false if there is not\ndef check_feats(item):\n  if isinstance(item, float):\n    return False\n  else:\n    return True\n\n# apply the function to the dataframe\ndf['has_feats'] = df['feats'].apply(check_feats)\n\n\n#%%\n# create a HP per level feature\ndf['HP_per_level'] = df['HP'] / df['level']\n\n\n#%%\ndf.head()\n\n\n#%%\n# drop uneeded columns due to high randomness or high variance\ndrop_columns_variance = ['name', 'date', 'day']\ndf = df.drop(columns = drop_columns_variance)\n\n# drop columns due to leakage\ndrop_columns_leak = ['subclass', 'class']\ndf = df.drop(columns = drop_columns_leak)\n\n# drop columns due to duplication\ndrop_columns_dup = ['race']\ndf = df.drop(columns = drop_columns_dup)\n\n# check the head\ndf.head()\n\n\n#%%\ndf['justClass'].value_counts()\n\n\n#%%\n# get our target\ntarget = 'justClass'\ntargetAllowed = ['Fighter', 'Rogue', 'Cleric', 'Barbarian', 'Paladin', 'Ranger', 'Sorcerer', 'Wizard', 'Monk', 'Druid', 'Bard', 'Warlock']\n\n\n#%%\n# df = df[df[target] targetAllowed]\ndf = df.loc[df[target].isin(targetAllowed)]\n\n\n#%%\ndf['justClass'].value_counts()\n\n\n#%%\n# get our features\ntrain_features = df.drop(columns=target)\nnumeric_features = train_features.select_dtypes(include='number').columns.tolist()\ncardinality = train_features.select_dtypes(exclude='number').nunique()\ncategorical_features = cardinality[cardinality <= 75].index.tolist()\nfeatures = numeric_features + categorical_features\n\n\n#%%\nfeatures\n\n\n#%%\n# majority class check\nmajority_class = df[target].mode()\nprint('Majority class is', majority_class)\ny_pred = [majority_class] * len(df)\naccuracy_score(df[target], y_pred)\n\n\n#%%\n# train test split the data (80/20)\ntrain, val = train_test_split(df, train_size=0.80, test_size=.20,\n                               stratify=df[target], random_state=42)\n\n\n#%%\nX_train = train[features]\ny_train = train[target]\nX_val = val[features]\ny_val = val[target]\n\n\n#%%\n# fit a pipeline (Decision Tree)\npipelineTree = make_pipeline(\n    ce.OneHotEncoder(use_cat_names=True),\n    SimpleImputer(strategy='mean'),\n    StandardScaler(),\n    DecisionTreeClassifier(max_depth=3)\n)\n\npipelineTree.fit(X_train, y_train)\n\n\n#%%\n# validation accuracy (Decision Tree)\ny_pred_tree = pipelineTree.predict(X_val)\nprint('Validation Accuracy', accuracy_score(y_val, y_pred_tree))\n\n\n#%%\ny_pred_tree\n\n\n#%%\n# fit a pipeline (Random Forest)\npipelineForest = make_pipeline(\n    ce.OneHotEncoder(use_cat_names=True),\n    SimpleImputer(strategy='mean'),\n    StandardScaler(),\n    RandomForestClassifier(n_estimators=50, random_state=42, n_jobs=-1)\n)\n\npipelineForest.fit(X_train, y_train)\n\n\n#%%\ny_pred_forest = pipelineForest.predict(X_val)\nprint('Validation Accuracy', accuracy_score(y_val, y_pred_forest))\n\n\n#%%\ny_pred_forest\n\n\n#%%\ntransformers = make_pipeline(\n    ce.OneHotEncoder(use_cat_names=True),\n    SimpleImputer(strategy='mean'),\n    StandardScaler()\n)\n\n# tranform the data\nX_train_transformed = transformers.fit_transform(X_train)\nX_val_transformed = transformers.transform(X_val)\n\neval_set = [(X_train_transformed, y_train),\n            (X_val_transformed, y_val)]\n\n\n#%%\n# model = RandomForestClassifier(n_estimators=50, random_state=42, n_jobs=-1)\n# model.fit(X_train_transformed, y_train)\n\n\n#%%\n\n\n\n#%%\nmodel = XGBClassifier(n_estimators=1000, n_jobs=-1)\nmodel.fit(X_train_transformed, y_train, eval_set=eval_set, early_stopping_rounds=10)\n\n\n#%%\n# Validation accuracy\ny_pred = model.predict(X_val_transformed)\nprint('Validation Accuracy', accuracy_score(y_val, y_pred))\n\n\n#%%\ny_pred\n\n\n#%%\n# permuter = PermutationImportance(\n#     model, \n#     scoring='accuracy',\n#     n_iter=3,\n#     random_state=42\n# )\n\n# permuter.fit(X_val_transformed, y_val)\n# feature_names = X_val.columns.tolist()\n\n# eli5.show_weights(\n#     permuter,\n#     top=None, # show importance of all features\n#     feature_names=feature_names\n# )\n\n\n#%%\n# the row to anaylze in the shaply plot\n# change the number in row to find the shaply value\nrow = 25\nrow = X_train.iloc[[row]]\n\n\n#%%\n# import shap\n\n# explainer = shap.TreeExplainer(model)\n# row_processed = transformers.transform(row)\n# shap_values = explainer.shap_values(row_processed)\n\n# shap.initjs()\n# shap.force_plot(\n#     base_value=explainer.expected_value,\n#     shap_values=shap_values,\n#     features=row\n# )\n\n\n#%%\n\n\n\n#%%\n\n\n\n", "meta": {"hexsha": "3ae22b567fe7527a95e09818baf0dce08cb6b9c9", "size": 9433, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks/Colab notebook.py", "max_stars_repo_name": "KyleHaggin/DnD-class-predictor", "max_stars_repo_head_hexsha": "f660614ac795c144904f7725ce0afcdf18ad7c52", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/Colab notebook.py", "max_issues_repo_name": "KyleHaggin/DnD-class-predictor", "max_issues_repo_head_hexsha": "f660614ac795c144904f7725ce0afcdf18ad7c52", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "notebooks/Colab notebook.py", "max_forks_repo_name": "KyleHaggin/DnD-class-predictor", "max_forks_repo_head_hexsha": "f660614ac795c144904f7725ce0afcdf18ad7c52", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.4229691877, "max_line_length": 228, "alphanum_fraction": 0.7263860914, "include": true, "reason": "import numpy", "num_tokens": 2434, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3849121303722487, "lm_q2_score": 0.13660839529884056, "lm_q1q2_score": 0.052582228461211}}
{"text": "# -*- coding: utf-8 -*-\n\"\"\"\nVarious small and named graphs, together with some compact generators.\n\n\"\"\"\n__author__ =\"\"\"Aric Hagberg (hagberg@lanl.gov)\\nPieter Swart (swart@lanl.gov)\"\"\"\n#    Copyright (C) 2004-2008 by \n#    Aric Hagberg <hagberg@lanl.gov>\n#    Dan Schult <dschult@colgate.edu>\n#    Pieter Swart <swart@lanl.gov>\n#    All rights reserved.\n#    BSD license.\n\n__all__ = ['make_small_graph',\n           'LCF_graph',\n           'bull_graph',\n           'chvatal_graph',\n           'cubical_graph',\n           'desargues_graph',\n           'diamond_graph',\n           'dodecahedral_graph',\n           'frucht_graph',\n           'heawood_graph',\n           'house_graph',\n           'house_x_graph',\n           'icosahedral_graph',\n           'krackhardt_kite_graph',\n           'moebius_kantor_graph',\n           'octahedral_graph',\n           'pappus_graph',\n           'petersen_graph',\n           'sedgewick_maze_graph',\n           'tetrahedral_graph',\n           'truncated_cube_graph',\n           'truncated_tetrahedron_graph',\n           'tutte_graph']\n\nimport networkx as nx\nfrom networkx.generators.classic import empty_graph, cycle_graph, path_graph, complete_graph\nfrom networkx.exception import NetworkXError\n\n#------------------------------------------------------------------------------\n#   Tools for creating small graphs\n#------------------------------------------------------------------------------\ndef make_small_undirected_graph(graph_description, create_using=None):\n    \"\"\"\n    Return a small undirected graph described by graph_description.\n\n    See make_small_graph.\n    \"\"\"\n    if create_using is not None and create_using.is_directed():\n        raise NetworkXError(\"Directed Graph not supported\")\n    return make_small_graph(graph_description, create_using)\n\ndef make_small_graph(graph_description, create_using=None):\n    \"\"\"\n    Return the small graph described by graph_description.\n\n    graph_description is a list of the form [ltype,name,n,xlist]\n\n    Here ltype is one of \"adjacencylist\" or \"edgelist\",\n    name is the name of the graph and n the number of nodes.\n    This constructs a graph of n nodes with integer labels 0,..,n-1.\n    \n    If ltype=\"adjacencylist\"  then xlist is an adjacency list\n    with exactly n entries, in with the j'th entry (which can be empty)\n    specifies the nodes connected to vertex j.\n    e.g. the \"square\" graph C_4 can be obtained by\n\n    >>> G=nx.make_small_graph([\"adjacencylist\",\"C_4\",4,[[2,4],[1,3],[2,4],[1,3]]])\n\n    or, since we do not need to add edges twice,\n    \n    >>> G=nx.make_small_graph([\"adjacencylist\",\"C_4\",4,[[2,4],[3],[4],[]]])\n    \n    If ltype=\"edgelist\" then xlist is an edge list \n    written as [[v1,w2],[v2,w2],...,[vk,wk]],\n    where vj and wj integers in the range 1,..,n\n    e.g. the \"square\" graph C_4 can be obtained by\n \n    >>> G=nx.make_small_graph([\"edgelist\",\"C_4\",4,[[1,2],[3,4],[2,3],[4,1]]])\n\n    Use the create_using argument to choose the graph class/type. \n    \"\"\"\n    ltype=graph_description[0]\n    name=graph_description[1]\n    n=graph_description[2]\n\n    G=empty_graph(n, create_using)\n    nodes=G.nodes()\n\n    if ltype==\"adjacencylist\":\n        adjlist=graph_description[3]\n        if len(adjlist) != n:\n            raise NetworkXError(\"invalid graph_description\")\n        G.add_edges_from([(u-1,v) for v in nodes for u in adjlist[v]])\n    elif ltype==\"edgelist\":\n        edgelist=graph_description[3]\n        for e in edgelist:\n            v1=e[0]-1\n            v2=e[1]-1\n            if v1<0 or v1>n-1 or v2<0 or v2>n-1:\n                raise NetworkXError(\"invalid graph_description\")\n            else:\n                G.add_edge(v1,v2)\n    G.name=name\n    return G\n\n\ndef LCF_graph(n,shift_list,repeats,create_using=None):\n    \"\"\"\n    Return the cubic graph specified in LCF notation.\n\n    LCF notation (LCF=Lederberg-Coxeter-Fruchte) is a compressed\n    notation used in the generation of various cubic Hamiltonian\n    graphs of high symmetry. See, for example, dodecahedral_graph,\n    desargues_graph, heawood_graph and pappus_graph below.\n    \n    n (number of nodes)\n      The starting graph is the n-cycle with nodes 0,...,n-1.\n      (The null graph is returned if n < 0.)\n\n    shift_list = [s1,s2,..,sk], a list of integer shifts mod n,\n\n    repeats\n      integer specifying the number of times that shifts in shift_list\n      are successively applied to each v_current in the n-cycle\n      to generate an edge between v_current and v_current+shift mod n.\n\n    For v1 cycling through the n-cycle a total of k*repeats\n    with shift cycling through shiftlist repeats times connect\n    v1 with v1+shift mod n\n          \n    The utility graph K_{3,3}\n\n    >>> G=nx.LCF_graph(6,[3,-3],3)\n    \n    The Heawood graph\n\n    >>> G=nx.LCF_graph(14,[5,-5],7)\n\n    See http://mathworld.wolfram.com/LCFNotation.html for a description\n    and references.\n    \n    \"\"\"\n    if create_using is not None and create_using.is_directed():\n        raise NetworkXError(\"Directed Graph not supported\")\n\n    if n <= 0:\n        return empty_graph(0, create_using)\n\n    # start with the n-cycle\n    G=cycle_graph(n, create_using)\n    G.name=\"LCF_graph\"\n    nodes=G.nodes()\n\n    n_extra_edges=repeats*len(shift_list)    \n    # edges are added n_extra_edges times\n    # (not all of these need be new)\n    if n_extra_edges < 1:\n        return G\n\n    for i in range(n_extra_edges):\n        shift=shift_list[i%len(shift_list)] #cycle through shift_list\n        v1=nodes[i%n]                    # cycle repeatedly through nodes\n        v2=nodes[(i + shift)%n]\n        G.add_edge(v1, v2)\n    return G\n\n\n#-------------------------------------------------------------------------------\n#   Various small and named graphs\n#-------------------------------------------------------------------------------\n\ndef bull_graph(create_using=None):\n    \"\"\"Return the Bull graph. \"\"\"\n    description=[\n        \"adjacencylist\",\n        \"Bull Graph\",\n        5,\n        [[2,3],[1,3,4],[1,2,5],[2],[3]]\n        ]\n    G=make_small_undirected_graph(description, create_using)\n    return G\n\ndef chvatal_graph(create_using=None):\n    \"\"\"Return the Chvátal graph.\"\"\"\n    description=[\n        \"adjacencylist\",\n        \"Chvatal Graph\",\n        12,\n        [[2,5,7,10],[3,6,8],[4,7,9],[5,8,10],\n         [6,9],[11,12],[11,12],[9,12],\n         [11],[11,12],[],[]]\n        ]\n    G=make_small_undirected_graph(description, create_using)\n    return G\n\ndef cubical_graph(create_using=None):\n    \"\"\"Return the 3-regular Platonic Cubical graph.\"\"\"\n    description=[\n        \"adjacencylist\",\n        \"Platonic Cubical Graph\",\n        8,\n        [[2,4,5],[1,3,8],[2,4,7],[1,3,6],\n         [1,6,8],[4,5,7],[3,6,8],[2,5,7]]\n        ]\n    G=make_small_undirected_graph(description, create_using)\n    return G\n\ndef desargues_graph(create_using=None):\n    \"\"\" Return the Desargues graph.\"\"\"\n    G=LCF_graph(20, [5,-5,9,-9], 5, create_using)\n    G.name=\"Desargues Graph\"\n    return G\n\ndef diamond_graph(create_using=None):\n    \"\"\"Return the Diamond graph. \"\"\"\n    description=[\n        \"adjacencylist\",\n        \"Diamond Graph\",\n        4,\n        [[2,3],[1,3,4],[1,2,4],[2,3]]\n        ]\n    G=make_small_undirected_graph(description, create_using)\n    return G\n\ndef dodecahedral_graph(create_using=None):\n    \"\"\" Return the Platonic Dodecahedral graph. \"\"\"\n    G=LCF_graph(20, [10,7,4,-4,-7,10,-4,7,-7,4], 2, create_using)\n    G.name=\"Dodecahedral Graph\"\n    return G\n\ndef frucht_graph(create_using=None):\n    \"\"\"Return the Frucht Graph.\n\n    The Frucht Graph is the smallest cubical graph whose\n    automorphism group consists only of the identity element.\n\n    \"\"\"\n    G=cycle_graph(7, create_using)\n    G.add_edges_from([[0,7],[1,7],[2,8],[3,9],[4,9],[5,10],[6,10],\n                [7,11],[8,11],[8,9],[10,11]])\n\n    G.name=\"Frucht Graph\"\n    return G\n\ndef heawood_graph(create_using=None):\n    \"\"\" Return the Heawood graph, a (3,6) cage. \"\"\"\n    G=LCF_graph(14, [5,-5], 7, create_using)\n    G.name=\"Heawood Graph\"\n    return G\n\ndef house_graph(create_using=None):\n    \"\"\"Return the House graph (square with triangle on top).\"\"\"\n    description=[\n        \"adjacencylist\",\n        \"House Graph\",\n        5,\n        [[2,3],[1,4],[1,4,5],[2,3,5],[3,4]]\n        ]\n    G=make_small_undirected_graph(description, create_using)\n    return G\n\ndef house_x_graph(create_using=None):\n    \"\"\"Return the House graph with a cross inside the house square.\"\"\"\n    description=[\n        \"adjacencylist\",\n        \"House-with-X-inside Graph\",\n        5,\n        [[2,3,4],[1,3,4],[1,2,4,5],[1,2,3,5],[3,4]]\n        ]\n    G=make_small_undirected_graph(description, create_using)\n    return G\n\ndef icosahedral_graph(create_using=None):\n    \"\"\"Return the Platonic Icosahedral graph.\"\"\"\n    description=[\n        \"adjacencylist\",\n        \"Platonic Icosahedral Graph\",\n        12,\n        [[2,6,8,9,12],[3,6,7,9],[4,7,9,10],[5,7,10,11],\n         [6,7,11,12],[7,12],[],[9,10,11,12],\n         [10],[11],[12],[]]\n        ]\n    G=make_small_undirected_graph(description, create_using)\n    return G\n    \n\ndef krackhardt_kite_graph(create_using=None):\n    \"\"\"\n    Return the Krackhardt Kite Social Network.\n \n    A 10 actor social network introduced by David Krackhardt\n    to illustrate: degree, betweenness, centrality, closeness, etc. \n    The traditional labeling is:\n    Andre=1, Beverley=2, Carol=3, Diane=4,\n    Ed=5, Fernando=6, Garth=7, Heather=8, Ike=9, Jane=10.\n    \n    \"\"\"\n    description=[\n        \"adjacencylist\",\n        \"Krackhardt Kite Social Network\",\n        10,\n        [[2,3,4,6],[1,4,5,7],[1,4,6],[1,2,3,5,6,7],[2,4,7],\n         [1,3,4,7,8],[2,4,5,6,8],[6,7,9],[8,10],[9]]\n         ]\n    G=make_small_undirected_graph(description, create_using)\n    return G\n\ndef moebius_kantor_graph(create_using=None):\n    \"\"\"Return the Moebius-Kantor graph.\"\"\"\n    G=LCF_graph(16, [5,-5], 8, create_using)\n    G.name=\"Moebius-Kantor Graph\"\n    return G    \n\ndef octahedral_graph(create_using=None):\n    \"\"\"Return the Platonic Octahedral graph.\"\"\"\n    description=[\n        \"adjacencylist\",\n        \"Platonic Octahedral Graph\",\n        6,\n        [[2,3,4,5],[3,4,6],[5,6],[5,6],[6],[]]\n        ]\n    G=make_small_undirected_graph(description, create_using)\n    return G\n    \ndef pappus_graph():\n    \"\"\" Return the Pappus graph.\"\"\"\n    G=LCF_graph(18,[5,7,-7,7,-7,-5],3)\n    G.name=\"Pappus Graph\"\n    return G\n\ndef petersen_graph(create_using=None):\n    \"\"\"Return the Petersen graph.\"\"\"\n    description=[\n        \"adjacencylist\",\n        \"Petersen Graph\",\n        10,\n        [[2,5,6],[1,3,7],[2,4,8],[3,5,9],[4,1,10],[1,8,9],[2,9,10],\n         [3,6,10],[4,6,7],[5,7,8]]\n        ]\n    G=make_small_undirected_graph(description, create_using)\n    return G\n\n\ndef sedgewick_maze_graph(create_using=None):\n    \"\"\"\n    Return a small maze with a cycle.\n\n    This is the maze used in Sedgewick,3rd Edition, Part 5, Graph\n    Algorithms, Chapter 18, e.g. Figure 18.2 and following.\n    Nodes are numbered 0,..,7\n    \"\"\" \n    G=empty_graph(0, create_using)\n    G.add_nodes_from(range(8))\n    G.add_edges_from([[0,2],[0,7],[0,5]])\n    G.add_edges_from([[1,7],[2,6]])\n    G.add_edges_from([[3,4],[3,5]])\n    G.add_edges_from([[4,5],[4,7],[4,6]])\n    G.name=\"Sedgewick Maze\"\n    return G\n\ndef tetrahedral_graph(create_using=None):\n    \"\"\" Return the 3-regular Platonic Tetrahedral graph.\"\"\"\n    G=complete_graph(4, create_using)\n    G.name=\"Platonic Tetrahedral graph\"\n    return G\n\ndef truncated_cube_graph(create_using=None):\n    \"\"\"Return the skeleton of the truncated cube.\"\"\"\n    description=[\n        \"adjacencylist\",\n        \"Truncated Cube Graph\",\n        24,\n        [[2,3,5],[12,15],[4,5],[7,9],\n         [6],[17,19],[8,9],[11,13],\n         [10],[18,21],[12,13],[15],\n         [14],[22,23],[16],[20,24],\n         [18,19],[21],[20],[24],\n         [22],[23],[24],[]]\n        ]\n    G=make_small_undirected_graph(description, create_using)\n    return G\n\ndef truncated_tetrahedron_graph(create_using=None):\n    \"\"\"Return the skeleton of the truncated Platonic tetrahedron.\"\"\"\n    G=path_graph(12, create_using)\n#    G.add_edges_from([(1,3),(1,10),(2,7),(4,12),(5,12),(6,8),(9,11)])\n    G.add_edges_from([(0,2),(0,9),(1,6),(3,11),(4,11),(5,7),(8,10)])\n    G.name=\"Truncated Tetrahedron Graph\"\n    return G\n\ndef tutte_graph(create_using=None):\n    \"\"\"Return the Tutte graph.\"\"\"\n    description=[\n        \"adjacencylist\",\n        \"Tutte's Graph\",\n        46,\n        [[2,3,4],[5,27],[11,12],[19,20],[6,34],\n         [7,30],[8,28],[9,15],[10,39],[11,38],\n         [40],[13,40],[14,36],[15,16],[35],\n         [17,23],[18,45],[19,44],[46],[21,46],\n         [22,42],[23,24],[41],[25,28],[26,33],\n         [27,32],[34],[29],[30,33],[31],\n         [32,34],[33],[],[],[36,39],\n         [37],[38,40],[39],[],[],\n         [42,45],[43],[44,46],[45],[],[]]\n        ]\n    G=make_small_undirected_graph(description, create_using)\n    return G\n\n", "meta": {"hexsha": "f41f8d0f06746b5fdef52132b7b68ef33aa0028e", "size": 12861, "ext": "py", "lang": "Python", "max_stars_repo_path": "networkx/generators/small.py", "max_stars_repo_name": "tempcyc/networkx", "max_stars_repo_head_hexsha": "cae83ba501c242567cb2454f97f851898276f06e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 12, "max_stars_repo_stars_event_min_datetime": "2015-03-25T20:20:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-14T19:44:56.000Z", "max_issues_repo_path": "networkx/generators/small.py", "max_issues_repo_name": "tempcyc/networkx", "max_issues_repo_head_hexsha": "cae83ba501c242567cb2454f97f851898276f06e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 71, "max_issues_repo_issues_event_min_datetime": "2015-01-05T16:50:55.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-30T19:17:47.000Z", "max_forks_repo_path": "networkx/generators/small.py", "max_forks_repo_name": "tempcyc/networkx", "max_forks_repo_head_hexsha": "cae83ba501c242567cb2454f97f851898276f06e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 14, "max_forks_repo_forks_event_min_datetime": "2015-02-15T22:19:18.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-30T18:54:54.000Z", "avg_line_length": 31.1404358354, "max_line_length": 92, "alphanum_fraction": 0.5896897597, "include": true, "reason": "import networkx,from networkx", "num_tokens": 3759, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49218813572079556, "lm_q2_score": 0.10669060246682488, "lm_q1q2_score": 0.05251184872707505}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# TODO:\n# \n# \n# R1: \n# - get in touch with ngspice developers to go over xspice's lcouple & magnetic core\n# - reivew the tcoil more in depth\n# \n# \n# R2:\n# - Get rest of standard transformer done\n# \n\n# In[1]:\n\n\nfrom skidl.pyspice import *\n#can you say cheeky \nimport PySpice as pspice\n#becouse it's written by a kiwi you know\nimport lcapy as kiwi\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport sympy as sym\n\nfrom scipy.signal import zpk2tf as scipy_zpk2tf\n\n\nfrom IPython.display import YouTubeVideo, display\n\nimport traceback\nimport warnings\n\n\n# In[2]:\n\n\n#import dc code from parral folder\nimport sys\nsys.path.insert(1, '../DC_1/')\nfrom DC_1_Codes import get_skidl_spice_ref\n\nfrom AC_2_Codes import *\n\nsym.init_printing()\n\n#notebook specific loading control statements \nget_ipython().run_line_magic('matplotlib', 'inline')\n#tool to log notebook internals\n#https://github.com/jrjohansson/version_information\nget_ipython().run_line_magic('load_ext', 'version_information')\nget_ipython().run_line_magic('version_information', 'skidl, PySpice,lcapy, sympy, numpy, matplotlib, pandas, scipy')\n\n\n# # Mutual Inductance and SPICE\n# \n# For a recollection of the basic theory of self and mutual inductance recall the YT video on the subject below from ALL ABOUT ELECTRONICS. However, let's be clear about this right now; SPICE is not a field simulator. SPICE just does a bit more than your EE 101/102 textbook. Though we will see there are ways to enhance the basic SPICE with XSPICE to implement more advanced magnetic device models. But even with XSPICE, we can still not get to the level of field solvers like Ansys who will do full E&M simulations and then extract the S-parameters and then use that as part of its SPICE incarnation.\n# \n\n# In[3]:\n\n\nYouTubeVideo('hoTInTKij0o', width=500, height=400)\n\n\n# The other thing to recall is that inductors in reference to other inductors are polarized elements and that polarization does have consequences as explained by ALL ABOUT ELECTRONICS in the YT video \"Dot Convention in Magnetically Coupled Circuits\"\n\n# In[4]:\n\n\nYouTubeVideo('sILgO4sQmRs', width=500, height=400)\n\n\n# Where in SPICE as we will see the dot belongs to the first terminal of the inductor. Further, to make SPICE aware of what inductors are coupled to which we use the `K` statement who’s SPICE syntax is\n# \n# ```\n# KXXXXXXX LYYYYYYY LZZZZZZZ value\n# ```\n# \n# Where `KXXXXXXX` is the name of the coupling, `LYYYYYYY` and `LZZZZZZZ` are the two inductors that are being coupled. And finally, value the value of the coefficient of coupling $k$ where $k$ can take on a value from 0 to 1 and is defined as\n# \n# $$k=\\dfrac{M}{\\sqrt{L_Y L_Z}}$$\n# \n# where $M$ is the mutual inductance between the two inductors and $L_Y$ & $L_Z$ are the values of the inductors of the two inductors respectively\n# \n\n# # Series Mutual inductance\n\n# The following is a quick testbench to when testing mutual inductance in SPICE\n\n# In[5]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 3 mutual_tester class\n#class to perform the analysis of the coupled inductors in section 3\n\nclass mutual_tester(ac_ease, ac_representation_tool, eecomplex_plot_templets):\n    \"\"\"\n    Quick class to test mutual inductance \n    \"\"\"\n    \n    def __init__(self, circ, title, start_freq=1@u_Hz, stop_freq=100@u_Hz):\n        \"\"\"\n        Quick class to test mutual inductance \n        \n        Args:\n            circ (pyspice circuit): circuit under test\n            title (str): title for plots\n            start_freq(float; Hertz; 1@u_Hz): the starting freauncy\n            stop_freq(float; Hertz; 100@u_Hz): the ending freauncy\n        \n        Returns:\n            does the ac sim of the circuit, produces the ac values transformed \n            in `self.ac_sim_mag_DF` ect and creates a bode plot of the results\n\n        \"\"\"\n        \n        #do what ac_ease is supposed to do at startup\n        #instainte the simulation from the circuit\n        ac_ease.__init__(self, circ)\n        #setup the simulation parameter with the helper method\n        self.ac_sweep_setup(start_freq, stop_freq, 20, 'decade', True)\n        #do the simulation\n        self.do_ac_sim()\n        \n        \n        #do what ac_representation_tool is supposed to do at startup\n        #and pass in the selfs from `ac_ease`'s ac_resultsNB_DF\n        ac_representation_tool.__init__(self, self.ac_resultsNB_DF)\n        #generate the representations\n        self.make_mag_phase()\n        \n        \n        eecomplex_plot_templets.__init__(self)\n\n\n        fig, ax_bode=plt.subplots(nrows=1, ncols=1) \n\n        self.bode_plot_one_templet(self.ac_sim_mag_DF.index, self.ac_sim_mag_DF['V1_[A][dB]'], self.ac_sim_phase_DF['V1_[A][deg]'], \n                          title='Source_Current_Draw', ax=ax_bode)\n\n        \n        fig.suptitle(title)\n\n\n# For each of the examples from ALL ABOUT ELECTRONICS here will create the circuit in three ways to see what effect mutual coupling has. The first is with no coupling. The second is invoking the mutual coupling. And the third case implementing the circuit with the theoretical simplification. This is followed by plotting all three cases on top of each other to see the effect of invoking mutual coupling and the theoretical simplification from SPICE’s view. \n\n# ## Series Adding Mutual Inductance from ALL ABOUT ELECTRONICS \"Mutually Coupled Inductors in Series (Derivation / Proof and Examples)\" @~ 6:04min\n\n# In[6]:\n\n\nYouTubeVideo('49OL_3L7BFA', width=500, height=400, start=364)\n\n\n# ### No Coupling\n\n# In[7]:\n\n\nreset()\n#create the nets\nnet_in=Net('In')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\nl1=L(value=3@u_H)\nl2=L(value=3@u_H)\nnet_in & l1[1, 2] & l2[1, 2] & gnd\n\n#k=K(ind1=l1, ind2=l2, coupling=0.5)\n\n\ncirc_nok=generate_netlist()\nprint(circ_nok)\n\n\n# In[8]:\n\n\nanylsis_nok=mutual_tester(circ_nok, 'No Coupling')\n\n\n# ### With Coupling\n\n# In[9]:\n\n\nreset()\n#create the nets\nnet_in=Net('In')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\nl1=L(value=3@u_H)\nl2=L(value=3@u_H)\nnet_in & l1[1, 2] & l2[1, 2] & gnd\n\nk=K(ind1=l1, ind2=l2, coupling=0.5)\n\n\ncirc_k=generate_netlist()\nprint(circ_k)\n\n\n# In[10]:\n\n\nanylsis_k=mutual_tester(circ_k, 'With Coupling')\n\n\n# ### Equivlint Single Inductor\n\n# In[11]:\n\n\nreset()\n#create the nets\nnet_in=Net('In')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\nl1=L(value=9@u_H)\nnet_in & l1[1, 2] & gnd\n\n\n\ncirc_eq=generate_netlist()\nprint(circ_eq)\n\n\n# In[12]:\n\n\nanylsis_eq=mutual_tester(circ_eq, 'Equivalent')\n\n\n# ### Comperion between all three cases\n\n# In[13]:\n\n\ncomp_plot=eecomplex_plot_templets()\nfig, [ax_mag, ax_phase]=plt.subplots(ncols=1, nrows=2)\ncomp_plot.bode_plot_two_templet(anylsis_nok.ac_sim_mag_DF.index,\n                               anylsis_nok.ac_sim_mag_DF['V1_[A][dB]'],\n                               anylsis_nok.ac_sim_phase_DF['V1_[A][deg]'],\n                        axs=[ax_mag, ax_phase]\n                               )\nax_mag.semilogx(anylsis_k.ac_sim_mag_DF.index, anylsis_k.ac_sim_mag_DF['V1_[A][dB]'], label='mitK')\nax_phase.semilogx(anylsis_k.ac_sim_mag_DF.index, anylsis_k.ac_sim_phase_DF['V1_[A][deg]'], label='mitK')\n\n\nax_mag.semilogx(anylsis_eq.ac_sim_mag_DF.index, anylsis_eq.ac_sim_mag_DF['V1_[A][dB]'], alpha=.4, label=\"eq\")\nax_phase.semilogx(anylsis_eq.ac_sim_mag_DF.index, anylsis_eq.ac_sim_phase_DF['V1_[A][deg]'], alpha=.4, label='eq')\n\nax_mag.legend()\nax_phase.legend()\nplt.suptitle('Compersion Bode plots of Serial Inductors')\nplt.tight_layout();\n\n\n# ## Series Opposing Mutual Inductance from ALL ABOUT ELECTRONICS \"Mutually Coupled Inductors in Series (Derivation / Proof and Examples)\" @~ 7:17min\n\n# In[14]:\n\n\nYouTubeVideo('49OL_3L7BFA', width=500, height=400, start=437)\n\n\n# ### No Coupling\n\n# In[15]:\n\n\nreset()\n#create the nets\nnet_in=Net('In')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\nl1=L(value=1@u_H)\nl2=L(value=4@u_H)\nnet_in & l1[1, 2] & l2[2, 1] & gnd\n\n#k=K(ind1=l1, ind2=l2, coupling=0.9)\n\n\ncirc_nok=generate_netlist()\nprint(circ_nok)\n\n\n# In[16]:\n\n\nanylsis_nok=mutual_tester(circ_nok, 'No Coupling')\n\n\n# ### With Coupling\n\n# In[17]:\n\n\nreset()\n#create the nets\nnet_in=Net('In')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\nl1=L(value=1@u_H)\nl2=L(value=4@u_H)\nnet_in & l1[1, 2] & l2[2, 1] & gnd\n\nk=K(ind1=l1, ind2=l2, coupling=0.9)\n\n\ncirc_k=generate_netlist()\nprint(circ_k)\n\n\n# In[18]:\n\n\nanylsis_k=mutual_tester(circ_k, 'With Coupling')\n\n\n# ### Equivalent Single Inductor\n\n# In[19]:\n\n\nreset()\n#create the nets\nnet_in=Net('In')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\nl1=L(value=1.4@u_H)\nnet_in & l1[1, 2] & gnd\n\n\n\ncirc_eq=generate_netlist()\nprint(circ_eq)\n\n\n# In[20]:\n\n\nanylsis_eq=mutual_tester(circ_eq, 'Equivalent')\n\n\n# ### Compersion between all three cases\n\n# In[21]:\n\n\ncomp_plot=eecomplex_plot_templets()\nfig, [ax_mag, ax_phase]=plt.subplots(ncols=1, nrows=2)\ncomp_plot.bode_plot_two_templet(anylsis_nok.ac_sim_mag_DF.index,\n                               anylsis_nok.ac_sim_mag_DF['V1_[A][dB]'],\n                               anylsis_nok.ac_sim_phase_DF['V1_[A][deg]'],\n                        axs=[ax_mag, ax_phase]\n                               )\nax_mag.semilogx(anylsis_k.ac_sim_mag_DF.index, anylsis_k.ac_sim_mag_DF['V1_[A][dB]'], label='mitK')\nax_phase.semilogx(anylsis_k.ac_sim_mag_DF.index, anylsis_k.ac_sim_phase_DF['V1_[A][deg]'], label='mitK')\n\n\nax_mag.semilogx(anylsis_eq.ac_sim_mag_DF.index, anylsis_eq.ac_sim_mag_DF['V1_[A][dB]'], alpha=.4, label=\"eq\")\nax_phase.semilogx(anylsis_eq.ac_sim_mag_DF.index, anylsis_eq.ac_sim_phase_DF['V1_[A][deg]'], alpha=.4, label='eq')\n\nax_mag.legend()\nax_phase.legend()\nplt.suptitle('Compersion Bode plots of Anti-Serial Inductors')\nplt.tight_layout();\n\n\n# # Parallel Mutual Inductance\n\n# ## Parallel Adding Mutual Inductance from ALL ABOUT ELECTRONICS \"Mutually Coupled Inductors in Parallel (Derivation / Proof and Examples)\" @~ 13:04min\n\n# In[22]:\n\n\nYouTubeVideo('NacczEJj_iI', width=500, height=400, start=784)\n\n\n# ### No Coupling\n\n# In[23]:\n\n\nreset()\n#create the nets\nnet_in=Net('In')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\nl1=L(value=1@u_H)\nl2=L(value=4@u_H)\nrdummy2=R(ref='dummy', value=0@u_Ohm)\n\nl1[1, 2]+=net_in, gnd\nrdummy2[1, 2]+=l1[1], l2[1]\nl2[2]+=gnd\n\n#k=K(ind1=l1, ind2=l2, coupling=0.5)\n\ncirc_nok=generate_netlist()\nprint(circ_nok)\n\n\n# In[24]:\n\n\nanylsis_nok=mutual_tester(circ_nok, 'No Coupling')\n\n\n# ### With Coupling\n\n# In[25]:\n\n\nreset()\n#create the nets\nnet_in=Net('In')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\nl1=L(value=1@u_H)\nl2=L(value=4@u_H)\nrdummy2=R(ref='dummy', value=0@u_Ohm)\n\nl1[1, 2]+=net_in, gnd\nrdummy2[1, 2]+=l1[1], l2[1]\nl2[2]+=gnd\n\nk=K(ind1=l1, ind2=l2, coupling=0.5)\n\ncirc_k=generate_netlist()\nprint(circ_k)\n\n\n# In[26]:\n\n\nanylsis_k=mutual_tester(circ_k, 'With Coupling')\n\n\n# ### Equivalent Single Inductor\n\n# In[27]:\n\n\nreset()\n#create the nets\nnet_in=Net('In')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\nl1=L(value=1@u_H)\nnet_in & l1[1, 2] & gnd\n\n#k=K(ind1=l1, ind2=l2, coupling=0.5)\n\ncirc_eq=generate_netlist()\nprint(circ_eq)\n\n\n# In[28]:\n\n\nanylsis_eq=mutual_tester(circ_eq, 'Equivalent Parallel Inductors')\n\n\n# ### Compersion between all three cases\n\n# In[29]:\n\n\ncomp_plot=eecomplex_plot_templets()\nfig, [ax_mag, ax_phase]=plt.subplots(ncols=1, nrows=2)\ncomp_plot.bode_plot_two_templet(anylsis_nok.ac_sim_mag_DF.index,\n                               anylsis_nok.ac_sim_mag_DF['V1_[A][dB]'],\n                               anylsis_nok.ac_sim_phase_DF['V1_[A][deg]'],\n                        axs=[ax_mag, ax_phase]\n                               )\nax_mag.semilogx(anylsis_k.ac_sim_mag_DF.index, anylsis_k.ac_sim_mag_DF['V1_[A][dB]'], label='mitK')\nax_phase.semilogx(anylsis_k.ac_sim_mag_DF.index, anylsis_k.ac_sim_phase_DF['V1_[A][deg]'], label='mitK')\n\n\nax_mag.semilogx(anylsis_eq.ac_sim_mag_DF.index, anylsis_eq.ac_sim_mag_DF['V1_[A][dB]'], alpha=.4, label=\"eq\")\nax_phase.semilogx(anylsis_eq.ac_sim_mag_DF.index, anylsis_eq.ac_sim_phase_DF['V1_[A][deg]'], alpha=.4, label='eq')\n\nax_mag.legend()\nax_phase.legend()\nplt.suptitle('Compersion Bode plots of Parallel Inductors')\nplt.tight_layout();\n\n\n# ## Parallel Opposing Mutual Inductance from ALL ABOUT ELECTRONICS \"Mutually Coupled Inductors in Parallel (Derivation / Proof and Examples)\" @~ 14:25min\n\n# In[30]:\n\n\nYouTubeVideo('NacczEJj_iI', width=500, height=400, start=865)\n\n\n# ### No Coupling\n\n# In[31]:\n\n\nreset()\n#create the nets\nnet_in=Net('In')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\nl1=L(value=1@u_H)\nl2=L(value=4@u_H)\nrdummy2=R(ref='dummy', value=0@u_Ohm)\n\nl1[1, 2]+=net_in, gnd\nrdummy2[1, 2]+=l1[1], l2[2]\nl2[1]+=gnd\n\n#k=K(ind1=l1, ind2=l2, coupling=0.5)\n\ncirc_nok=generate_netlist()\nprint(circ_nok)\n\n\n# In[32]:\n\n\nanylsis_nok=mutual_tester(circ_nok, 'Anti-Parallel Inductor with No Coupling')\n\n\n# ### With Coupling\n\n# In[33]:\n\n\nreset()\n#create the nets\nnet_in=Net('In')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\nl1=L(value=1@u_H)\nl2=L(value=4@u_H)\nrdummy2=R(ref='dummy', value=0@u_Ohm)\n\nl1[1, 2]+=net_in, gnd\nrdummy2[1, 2]+=l1[1], l2[2]\nl2[1]+=gnd\nk=K(ind1=l1, ind2=l2, coupling=0.5)\n\ncirc_k=generate_netlist()\nprint(circ_k)\n\n\n# In[34]:\n\n\nanylsis_k=mutual_tester(circ_k, 'Anti-Parallel Inductors with Coupling')\n\n\n# ### Equivalent Single Inductor\n\n# In[35]:\n\n\nreset()\n#create the nets\nnet_in=Net('In')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\nl1=L(value=1@u_H)\nnet_in & l1[1, 2] & gnd\n\n#k=K(ind1=l1, ind2=l2, coupling=0.5)\n\ncirc_eq=generate_netlist()\nprint(circ_eq)\n\n\n# In[36]:\n\n\nanylsis_eq=mutual_tester(circ_eq, 'Equivalent Anti-Parallel Inductor')\n\n\n# ### Compersion between all three cases\n\n# In[37]:\n\n\n#compare without K, with K, theoretical equivalent \ncomp_plot=eecomplex_plot_templets()\nfig, [ax_mag, ax_phase]=plt.subplots(ncols=1, nrows=2)\ncomp_plot.bode_plot_two_templet(anylsis_nok.ac_sim_mag_DF.index,\n                               anylsis_nok.ac_sim_mag_DF['V1_[A][dB]'],\n                               anylsis_nok.ac_sim_phase_DF['V1_[A][deg]'],\n                        axs=[ax_mag, ax_phase]\n                               )\nax_mag.semilogx(anylsis_k.ac_sim_mag_DF.index, anylsis_k.ac_sim_mag_DF['V1_[A][dB]'], label='mitK')\nax_phase.semilogx(anylsis_k.ac_sim_mag_DF.index, anylsis_k.ac_sim_phase_DF['V1_[A][deg]'], label='mitK')\n\n\nax_mag.semilogx(anylsis_eq.ac_sim_mag_DF.index, anylsis_eq.ac_sim_mag_DF['V1_[A][dB]'], alpha=.4, label=\"eq\")\nax_phase.semilogx(anylsis_eq.ac_sim_mag_DF.index, anylsis_eq.ac_sim_phase_DF['V1_[A][deg]'], alpha=.4, label='eq')\n\nax_mag.legend()\nax_phase.legend()\n\nplt.suptitle('Compersion Bode plots of Anti-Parallel Inductors')\nplt.tight_layout();\n\n\n# # Purposely designed Mutual Inductive Element; The Razivi T-Coil\n# \n# So, the question that should be asked is when does mutual induction come into play outside of transformers. From a field’s standpoint, mutual induction can be used in testing the effect of placing inductors too close to each other in layout by extracting $k$ from the field simulation. But it does have uses. One of which that shows up a lot in high-speed SERDES is the Razivi T-Coil where a paper on the topology can be found there: [The Bridged T-Coil](https://www.seas.ucla.edu/brweb/papers/Journals/BRFall15TCoil.pdf).\n# \n# A study of a variation of the T-coil was given by Jordan Edmunds in a two-part YT video on the subject. Where we will recreate the example from part two.\n# \n\n# In[38]:\n\n\nYouTubeVideo('-kSSMOAhlwU', width=500, height=400)\n\n\n# In[39]:\n\n\nYouTubeVideo('vr2oYehKC8Q', width=500, height=400)\n\n\n# In[40]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 3 t_coil class\n#class with lcapy and skidl subcircuit to create a T-coil from https://youtu.be/vr2oYehKC8Q\n\nclass t_coil():\n    def __init__(self, subcirc_ref=None, L_value=375@u_nH, K_value=1.0/3.0, CB_value=.125@u_pF, CL_value=1@u_pF):\n        \"\"\"\n        T-Coil example from https://youtu.be/vr2oYehKC8Q example\n        \n        Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            L_value (float; 375@u_nH; Henerys):  inductance of each of the two inductors in the T-coil\n            K_value (float; 1/3): the magnetic coupling between the two inductors\n            CB_value (float; .125@u_pF; Farads): capacitance of the bridge capacitor between the two coils\n            CL_value (float; 1@u_pF; Farads): capacitance of the shunt capacitor between the two cols\n        \n        Returns:\n            None\n        TODO:\n            -add assertions\n\n        \"\"\"\n        \n        self.subcirc_ref=subcirc_ref\n        self.L_value=L_value\n        self.K_value=K_value\n        self.CB_value=CB_value\n        self.CL_value=CL_value\n    \n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_Termanals - T-coil - Right_Termanals\n                             +----+  \n        Postive V_i   term_0-|0  2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1  3|-term_3     Negtive V_o\n                             +----+\n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RC lowpass filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        if self.subcirc_ref!=None:\n            CBref={'ref':f'CB_{self.subcirc_ref}'}\n            CLref={'ref':f'CL_{self.subcirc_ref}'}\n            LLref={'ref':f'LL_{self.subcirc_ref}'}\n            LRref={'ref':f'LR_{self.subcirc_ref}'}\n        \n        else:\n            CBref={}\n            CLref={}\n            LLref={}\n            LRref={}\n        \n        self.cb=C(value=self.CB_value, **CBref)\n        self.cl=C(value=self.CL_value, **CLref)\n        self.ll=L(value=self.L_value, **LLref)\n        self.lr=L(value=self.L_value, **LRref)\n        self.mul=K(ind1=self.ll, ind2=self.lr, coupling=self.K_value)\n        \n        term_0 & self.ll[2, 1]  & self.lr[2, 1] & term_2\n        self.cb['p', 'n']+=term_0, term_2\n        self.cl['p', 'n']+=self.ll[1], term_1\n        term_1+=term_3\n        \n        if return_elements:\n            return self.cb, self.cl, self.ll, self.lr, self.mul\n        \n        \n        \n        \n    def lcapy_self(self, draw_me=True, with_values=True):\n        \"\"\"\n        Creates a lcapy schematic of this classes filter that\n        can be used for amongst other things: draw a basic schematic\n        of this class circuit, extract the transfer function, \n        extract the 2Port Representation\n        \n        Args:\n            draw_me (bool): will draw a schematic of this classes circuit schematic\n            \n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract simply variables\n            \n        Return:\n            the lcapys circuit object is stored in `self.schematic` and will\n            have abstract sympy variable for the elements if `with_values` is False\n            and will draw the schematic of just this classes filter if `draw_me` is True\n        \n        TODO:\n            - Figure out how to add the K dots\n            - get the Vin statement into the schematic\n        \n        \"\"\"\n        self.with_values=with_values\n        \n        \n        self.schematic=kiwi.Circuit()\n        self.schematic.add('W 1 1_1; right=2')\n        self.schematic.add('W 0 0_1; right')\n        \n        self.schematic.add('Ll N1 0_1; left')\n        self.schematic.add('Lr N1 2_1; right')\n        self.schematic.add('Cl N1 1_1; down')\n        \n        self.schematic.add('W 0_1 0_2; up')\n        self.schematic.add('W 2_1 2_2; up')\n        self.schematic.add('Cb 0_2 2_2; right')\n        \n        self.schematic.add('W 2_1 2; right=1.5')\n        self.schematic.add('W 1_1 3; right=1.5')\n        self.schematic.add('P2 2 3; down, v=V_o')\n        \n        \n        if with_values:\n            self.schematic=self.schematic.subs({\n                'Ll':self.L_value,\n                'Lr':self.L_value,\n                'Cl':self.CL_value,\n                'Cb':self.CB_value})\n        \n        if draw_me:\n            self.schematic.draw()\n    \n    def get_tf(self, with_values=True, ZPK=True):\n        \"\"\"\n        will extract the symbolic transfer function for this filter\n        \n        Args:\n            with_values (bool): will push the filters element values into\n                the resulting lcapy circuit object in place of abstract sympy variables\n            \n            ZPK (bool): if True will try to return the TF in zero-pole-gain form\n                else will try to return the TF in canonical form \n                where the unity coefficient is the highest power of the denominator\n        \n        \"\"\"\n        self.lcapy_self(draw_me=False, with_values=with_values)\n        self.tf=self.schematic.transfer(0, 1, 2, 3)\n        \n        if ZPK:\n            return self.tf.ZPK()\n        else:\n            return self.tf.canonical()\n        \n    def get_twoPort(self, network_rep='Y', with_values=True):\n        \"\"\"\n        Gets the 2Port network representation of this filter.\n        The 2Port representation can be controlled\n        \n        Args:\n            network_rep (str; 'Y'): control string for what\n                representation is used to choose from:\n                \n                'Z': two-port Z-parameters matrix\n                'Y': two-port Y-parameters matrix\n                'H': two-port H-parameters matrix\n                'G': two-port G-parameters matrix\n                'ABCD': two-port A-parameters matrix\n                'invABCD': two-port B-parameters matrix\n                'S': two-port S-parameters matrix\n                'T': two-port T-parameters matrix\n                \n                \n        \"\"\"\n        \n        self.lcapy_self(draw_me=False, with_values=with_values)\n        \n        #create an action dict to get the 2P rep\n        rep_actions={\n            'Z':lambda x: x.Zparams(0, 1, 2, 1),\n            'Y':lambda x: x.Yparams(0, 1, 2, 1), \n            'H':lambda x: x.Hparams(0, 1, 2, 1),\n            'G':lambda x: x.Gparams(0, 1, 2, 1),\n            'ABCD':lambda x: x.Aparams(0, 1, 2, 1),\n            'invABCD':lambda x: x.Bparams(0, 1, 2, 1),\n            'S':lambda x: x.Sparams(0, 1, 2, 1),\n            'T':lambda x: x.Tparams(0, 1, 2, 1),\n        }\n        \n        assert network_rep in rep_actions.keys(), f'`{network_rep}` is not 2Port rep'\n        \n        return rep_actions[network_rep](self.schematic)\n\n\n# In[41]:\n\n\nT_coil=t_coil()\nT_coil.lcapy_self()\n\n\n# In[42]:\n\n\n#get this filters abstract transfer function\nT_coil.get_tf(with_values=False, ZPK=False)\n\n\n# In[43]:\n\n\n#get this filters transfer function\nT_coil.get_tf(with_values=True, ZPK=False)\n\n\n# In[44]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\nT_coil.SKiDl(net_in, gnd, net_out, gnd)\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In[45]:\n\n\nt_coil_resp=qfilter_explorer(circ, 'Equivalent', start_freq=1e7, stop_freq=1e10)\n\n\n# In[46]:\n\n\nt_coil_resp.symbolic_tf(T_coil)\n\n\n# # Transformers\n# \n# Am just doing a basic transformer with XSPICE will come back and do the specialty ones at a later time\n\n# ## Basic Transformer with XSPICE¶\n# \n# With just SPICE the transformer is modeled as a pair of coupled inductors with a coupling constant between them. So this doesn't work well for transformers. Yes, we could do it this way but it would be a laughable facsimile to a real transformer with real cores. And again SPICE is not a field solver. So to increase the capability of SPICE more advanced models have been developed. Unfortunately, most of these SPICE enhancements get swallowed up by proprietary EDA companies. But there is a major extension to Berkely's SPICE (what the core of ngspice is based on) via the Georgia Tech Research Institute that is open source and has been integrated into ngspice; XSPICE.\n# \n# Here we will just start using XSPICE to create a very simple implementation of a transformer based on what is in the ngspice documentation. But of course, we will do this with SKiDl and wrap it in a class that can give a user or developer a template to bespoke it to their needs.\n# \n\n# ## Quick rundown on instantiating XSPICE elements with SKiDl\n# \n# While XSPICE has a whole part of the ngspice manual dedicated to it (typically Part 2) the basic XSPICE elements are typically documented in Part 1 Chapter 12 \"Mixed-Mode and Behavioral Modeling with XSPICE\". The important parts of that chapter are \"Table 12.1: Port Type Modifiers\" and Section 12.5 \"Predefined Node Types for event-driven simulation\". The rest of the chapter is broken down into three main sections:\n# \n# -\tAnalog Models (12.2): these are XSPICE elements with both analog input and outputs like Diodes, S-Domain Transfer Functions, Memristors, etc\n# \n# -\tHybrid Models (12.3): these are XSPICE elements with a mixture of analog and digital IOs such as DAC, ADC, Controlled Digital Oscillators\n# \n# -\tDigital Models (12.4): there XSPICE elements with full digital IOs such as RTL logic primitives of AND, NAND, NOR, Latches, and Flip-Flops\n# \n# To create the primitive XSPICE transformer we are going to need two XSPICE *Inductive Coupling* elements (12.2.18) and one XSPICE *Magnetic Core* element (12.2.19)\n# \n# Let's just do a walkthrough of invoking an *Inductive Coupling* element in SKiDl. First off in the ngspice documentation all XSPICE elements are documented with a three-column table where at the top of the table we get some basic info for the element. What we are after here is the **Spice_Model_Name** row which in this case is `lcouple`. This tells the engine what XSPICE element were using like how `V` tells the engine that the element is a voltage source. The next main section in the table is the Port description *PORT_TABLE* where for each port it has an entry. Notice for an lcouple element it has two ports `l` and `mmf_out` in the center and far left column respectively. For each port, the most important info is **Allowed_Types** were to understand the cryptic type codes we need to refer to \"Table 12.1: Port Type Modifiers\". For `l` we have two allowed types `h` which is a single-ended input referenced to ground, and `hd` which is a differential input with no reference. Here's the thing, the translation from SKiDl though PySPICE to ngspice will not infer the grounded connection therefore go with the high number of terminals. So in this case port `l` will have two terminals where we are free to make the names of them whatever we want, will go with `io1` and `io2` respectively, but that is your choice though the DOT will go with the first terminal. For the other port `mmf_out` it is only a hd port so we have to create two terminals for it that again can be arbitrarily named but we will go with `mmf1`, `mmf2` here. This is the port that outputs the magnetic flux \"current\" to another lcouple element or magnetic core element. The last section is the *PARAMETER_TABLE* which can be quite extensive, but for the lcouple element is just a single parameter. Where each parameter will have info about its type, default value, bounds, etc. Where that can, and in our transformer class, used to write the parameter assertions. For an lcouple element, the only parameter is `num_turns` which is the number of turns for that particular lcouple element. Which, we will write the assertion to be that `num_turns` must be an integer greater than or equal to 1. Armed with the info we need to invoke our element lets look at doing so with SKiDl\n\n# The follwing will be a non function cirucit to demnstrate instaint xarray elements with SKiDl before the exstaince class for a full transfomer. We start by create a varibel that holds the number of turns for this inductor and follow it up with an assertion to make sure only valid inputs are allowed\n\n# In[47]:\n\n\n#var to hold the number of turns\nN_turns=5\n#assertion\nassert isinstance(N_turns, int) and N_turns>=1, 'N_turns must be int >=1'\n\n\n# We then instantiate the lcouple instance and tie it into the circuit as follows and then dissect what was done\n\n# In[48]:\n\n\n#refrance lines number in markdown below don't change them\nreset()\n#create some dummy nets \nio1_dnet=Net('io1D'); io2_dnet=Net('io2D'); mmf1_dnet=Net('mmf1D'); mmf2_dnet=Net('mmf1D')\n\n#instatine the XSPICE lcouple elment\nl_couple_ex = A( # `A` is the ngspice control leter for XSPICE elements\n            io=\"io1, io2, mmf1, mmf2\",  #io1 & io2 \\in port`l` and `mmf1` & `mmf2` \\in port `mmf_out`\n            model=XspiceModel( #`model` is filling in the blank for a `A` element and `XspiceModel` for SkiDl\n                \"ex_lcouple\", #name for this element instance\n                \"lcouple\", #what type of XSPICE element this is\n                num_turns=N_turns #element parameters as kwargs\n            ),\n        )\n\n#tie in the lcouple element to the nets\n#first tie to the circuit\nl_couple_ex['io1', 'io2']+=io1_dnet, io2_dnet\n#second tie for the flux\nl_couple_ex['mmf1', 'mmf2']+=mmf1_dnet, mmf2_dnet\n\ncirc=generate_netlist()\nprint(circ)\n\n\n# In line 7 we instantiate the XSPICE element within a SPICE element type `A`. This is followed up in line 8 with the declaration/creation of the IO terminals. The first port `l` is a `hd` type port therefore differential terminals are appropriately instantiated as `io1` & `io2` followed with port `mmf_out` which is only a `hd` type and so has the arbitrary terminals `mmf1` & `mmf2`. Both these ports are done in one string `\"io1, io2, mmf1, mmf2\"`. Next in line 9, we invoke `model=XspiceModel` where XspiceModel is the pass-through handler from SKiDl through to the ngspice netlist. The first argument of `XspiceModel` is the name of this element instance in line 10 `ex_lcouple`; where for the full transformer below this will be more descriptive with `primary` and `secondary` to indicate which lcouple element is taking on wich role. The next argument of `XspiceModel` in line 11 must be the **Spice_Model_Name** from the elements document table in the ngspice manual where for a lcouple it's lcouple. The rest of the arguments are pythonic kwags inputs where the argument is the parameter verbatim of its **Parameter_Name:** in the documentation table then set equal to the value we want it to take. In lcouple elements, there is only a single parameter `num_turns` that we set equal to our variable `N_turns` in line 12. From there we have a now standard SkiDl element that we attach to the rest of the circuit like normal. Thou what actually attaches to what is dictated by the port type and what it's meant to do. For a lcouple element port `mmf_out` which is made of terminals `mmf1` & `mmf2` is intended to pass a representation of the magnetic flux to either another lcouples `mmf_out` port or to a magnetic core element.\n\n# ## XSPICE made primitive Transformer\n# \n# Now know how to translate an XSPICE element from the ngspice docs to a SKiDl element. We now construct a class to act as a very primitive transformer model. And by primitive we mean it does not take into account the resistive and capacitive nature of each of the ports that must be modeled for a more sophisticated transformer model. All the values and basic configuration are taken from the ngspice 32 manual section 12.2.19 examples\n# \n\n# In[49]:\n\n\n#%%writefile -a AC_2_Codes.py\n#chapteer 2 section 3 basic_xspice_transformer class\n#class with skidl subcircuit to create primitive XSPICE transformer-based\n#on the ex in ngspice 32 manual section 12.2.19\n\nclass basic_xspice_transformer():\n    \"\"\"\n    Basic XSPICE based two-port transformer based on the example\n    in ngspice 32 manual section 12.2.19\n    \"\"\"\n    \n    def __init__(self, subcirc_ref=None, prim_turns=1, sec_turns=1, parallel=True):\n        \"\"\"\n        Create a primitive two-port transformer with a magnetic core\n        where core parameters are set in `self.core_specs`\n        \n       Args:\n            subcirc_ref (str): reference to use for the base of the internal elements\n            prim_turns (int; 1; None): the number of turns on the primary port \n                of the transformer must be an int >=1\n            \n            sec_turns (int; 1; None): the number of turns on the primary port \n                of the transformer must be an int >=1\n            \n            parallel (bool; True): If True will put the primary and secondary ports\n                in parallel dot configuration else will put them in anti- parallel config\n            \n        Returns:\n            None\n        TODO:\n            -really investigate the anti parrel config to make sure it's working\n                as it's supposed to\n\n    \n        \"\"\"\n        self.subcirc_ref=subcirc_ref\n        \n        assert prim_turns>=1 and sec_turns>=1, 'turns must be >= 1'\n        self.prim_turns=prim_turns; self.sec_turns=sec_turns\n        \n        self.parallel=parallel\n        \n        self.core_specs()\n    \n    def core_specs(self, \n                   H_array=None, B_array=None, \n                   area=0.01, length=0.01, \n                   input_domain=0.01, \n                   fraction=True, \n                   mode=1, \n                   in_low=-7.0, in_high=7.0,\n                   hyst=2.3, out_lower_limit=-2.5e-4,\n                   out_upper_limit=2.5e-4,\n                  #tried to make it look like the table in the ngspice manual\n                  make_plot=False):\n        \"\"\"\n        Access method to set all the core properties, if `make_plot` is true \n        will produce a plot of the BH curve\n        \n        Args:\n        (see assertions in code below for each inputs constraints)\n        (default values are taken from the two examples in ngspice 32 12.2.19,\n        not from the default values in `core`'s docs )\n        \n            H_array (np.array/None; None; ATurns/m): array for the core's main BH curve H values\n             if None will use default in the ngspice 32 manual examples in 12.2.19;\n             used only in pwl mode\n            \n            B_array (np.array/None; None; T):array for the core's main BH curve B values\n             if None will use default in the ngspice 32 manual examples in 12.2.19; \n             used only in pwl mode\n            \n            area (float; 0.01; m^2): the cross-section area of the core such that the flux\n                will be \\psi=B *A where A is the area and B is the B part of the BH curve; \n                used only in pwl mode\n                \n            length (float; 0.01; m): length of the core will scall the io mmf such that\n            H=mmf/L where H is the H part of the BH curve, mmf is the IO mmf and L is the length; \n            used only in pwl mode\n            \n            input_domain (float; 0.01; ?): docs are not clear what this is\n            \n            fraction (bool; True): if True apply smoothing to the BH curve vs nearest value in BH curve array\n            \n            mode (int; 1): if `1` use a pwl model of the core else `2` use a hysteresis model\n            \n            in_low (float; -7.0; ?): input low value, ?; used only when using hysteresis mode\n            \n            in_high (float; 7.0; ?): input high value, ?; used only when using hysteresis mode\n            \n            hyst (float; 2.3; ?): hysteresis, ?; used only when using hysteresis mode\n            \n            out_lower_limit (float; -2.5e-4; ?): ouput lower limit. ? ; used only when using hysteresis \n            \n            out_upper_limit (float; 2.5e-4; ?): ouput upper limit, ? ; used only when using hysteresis \n            \n            make_plot (bool; False): if True create a plot of the BH curve and\n                returns that plots axis\n            \n        \n        Returns:\n            create atriputes of XSPICE core parmaters like `self.*_V` that \n            hold the parmter value to pass to the core instaince in `self.SKiDl`.\n            If `make_plot` is True will create plot of BH curve and retrun it's axis\n            \n        \n        TODO:\n            - beef up the docs about the hysteresis from a source other then the ngspice manual\n            - beef up the plots\n        \n        \n        \"\"\"\n        \n        if (H_array==None) or (B_array==None):\n            assert (H_array is None) and (B_array is None), 'Both H & B must be None or equal np.arrays'\n            H_array=np.array([-1000, -500, -375, -250, -188, -125, -63, 0, 63, 125, 188, 250, 375, 500, 1000])\n            B_array=np.array([-3.13e-3, -2.63e-3, -2.33e-3, -1.93e-3, -1.5e-3, -6.25e-4, -2.5e-4, 0, 2.5e-4, 6.25e-4, 1.5e-3, 1.93e-3, 2.33e-3, 2.63e-3, 3.13e-3])\n        else:\n            assert isinstance(H_array, (np.ndarray, np.generic) ) and isinstance(H_array, (np.ndarray, np.generic) ), 'Both H & B must be None or eual np.arrays'\n        \n        assert (H_array.shape==B_array.shape) and (H_array.shape[0]>1) and (H_array.ndim==1), 'H and B arrays must be eual 1 dim arrays'\n        self.H_array_V=H_array; self.B_array_V=B_array  \n        \n        assert isinstance(area, float) and (area>=0), 'area must be a float >=0'\n        self.area_V=area\n        \n        assert isinstance(length, float) and (length>=0), 'length must be a float >=0'\n        self.length_V=length\n        \n        assert isinstance(input_domain, float) and (input_domain>=1e-12) and (input_domain<=0.5), 'input_domain must be a float >=1e-12 and <=0.5'\n        self.input_domain_V=input_domain\n        \n        assert isinstance(fraction, bool), 'fraction must be a bool'\n        self.fraction_V=fraction\n        \n        assert mode in [1,2], 'mode is a control value 1:pwl, 2:hyst; only'\n        self.mode_V=mode\n        \n        assert isinstance(in_low, float) and (in_low<in_high), 'in_low must be a float less then in_high'\n        self.in_low_V=in_low\n        \n        assert isinstance(in_high, float) and (in_low<in_high), 'in_high must be a float greater then in_low'\n        self.in_high_V=in_high\n        \n        assert isinstance(hyst, float) and (hyst>0.0), 'hyst must be a float greater than 0'\n        self.hyst_V=hyst\n        \n        assert isinstance(out_lower_limit, float) and (out_lower_limit<out_upper_limit), 'out_lower_limit must be a float less then in_high'\n        self.out_lower_limit_V=out_lower_limit\n        \n        assert isinstance(out_upper_limit, float) and (out_lower_limit<out_upper_limit), 'out_upper_limit must be a float less then out_lower_limit'\n        self.out_upper_limit_V=out_upper_limit\n        \n        \n        if make_plot:\n            fig, ax=plt.subplots(ncols=1, nrows=1)\n            \n            ax.plot(self.H_array_V, self.B_array_V, marker='o' , label='Main BH Curve')\n            ax.set_xlabel('magfield_H_[ATurns/m]'); ax.set_ylabel('flux_density_B_[T]')\n            ax.axvline(color='black', linestyle='--', alpha=0.5); ax.axhline(color='black', linestyle='--', alpha=0.5)\n            ax.grid()\n            ax.legend()\n            if self.subcirc_ref==None:\n                title=''\n            else:\n                title=self.subcirc_ref\n            ax.set_title(f'B-H Curve for Transfomer {title}')\n            \n            return ax\n    @subcircuit\n    def SKiDl(self, term_0, term_1, term_2, term_3, return_elements=False):\n        \"\"\"\n        Terminals:\n        term_0, term_1, term_2, term_3\n        \n        Terminals are defined via:\n        ```\n        Left_(prime)Termanals - Transformer - Right_(sec)Termanals\n                    (dot)   +--core--+  (dot if parallel)\n        Postive V_i   term_0-|0 || 2|-term_2     Postive V_o\n        Negtive V_i   term_1-|1 || 3|-term_3     Negtive V_o\n                             +------+ (dot if anti-parallel) \n        ```\n        \n        Args:\n            return_internls (bool; False): If True return out the internal Voltage Source,\n                and Resistance objects in this package\n        Returns:\n            Returns elements to circuit RC lowpass filter part element object and if `return_internls`\n            is True will return the internal voltage and resistance objects in that order \n        \"\"\"\n        \n        # Creating an XSPICE part using the SPICE abbreviation 'A'.\n        #Createing the primary side\n        prim = A(\n            io=\"io1, io2, mmf1, mmf2\",  #io1 & io2 \\in port`l` and `mmf1` & `mmf2` \\in port `mmf_out`\n            model=XspiceModel(\n                f\"prim_{self.subcirc_ref}\",\n                \"lcouple\",\n                num_turns=self.prim_turns\n            ),\n        )\n        \n        #creating the secondary side\n        sec = A(\n            io=\"io1, io2, mmf1, mmf2\", \n            model=XspiceModel(\n                f\"sec_{self.subcirc_ref}\",\n                \"lcouple\",\n                num_turns=self.sec_turns\n            ),\n        )\n        \n        #connect the \"inductors\" to the outside world\n        #the lcouples did not like having their ports named just 1, 2\n        prim['io1', 'io2']+=term_0, term_1\n        if self.parallel:\n            sec['io1', 'io2']+=term_2, term_3\n        else:\n            sec['io2', 'io1']+=term_2, term_3\n        \n        \n        #instatnint the core\n        core=A(\n            io=\"top, bot\", #couldnt think of a better i/o name \n            model=XspiceModel(\n                f'core_{self.subcirc_ref}',\n                'core',\n                H_array=self.H_array_V.tolist(),\n                B_array=self.H_array_V.tolist(),\n                area=self.area_V,\n                length=self.length_V,\n                input_domain=self.input_domain_V,\n                fraction=self.fraction_V,\n                mode=self.mode_V,\n                in_low=self.in_low_V,\n                in_high=self.in_high_V,\n                hyst=self.hyst_V,\n                out_lower_limit=self.out_lower_limit_V,\n                out_upper_limit=self.out_upper_limit_V\n\n            )\n        )\n        \n        \n        #connect the core to the mmf control i/o for the lcoupled inductors\n        #direct connect of the `mmfs`'s together yield singular matrix, gnd should be fine\n        prim['mmf1', 'mmf2']+=core['top'], gnd\n        if self.parallel:\n            sec['mmf1', 'mmf2']+=core['bot'], gnd\n        else:\n            sec['mmf2', 'mmf1']+=core['bot'], gnd\n    \n    def lcapy_self(self):\n        \"\"\"\n        leaving off all the lcapy stuff since it won't do anti parral config\n        \"\"\"\n        pass\n\n\n# ## Parallel Primary and Seconday configeration\n\n# In[50]:\n\n\ntransformer=basic_xspice_transformer(prim_turns=2, sec_turns=5)\n#dont change any core prop, but make the plot \ntransformer.core_specs(make_plot=True);\n\n\n# In[51]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\n\n#conenct the subcircuit\ntransformer.SKiDl(net_in, gnd, net_out, gnd)\n\n#create a load\nrload=R(ref='load', value=100@u_Ohm)\nload_amm=V(ref='amm_load', dc_value=0)\nnet_in & rload & load_amm & gnd\n\ncirc=generate_netlist(libs=\"SpiceLib\")\nprint(circ)\n\n\n# In[52]:\n\n\ntrans_sim=ac_ease(circ)\ntrans_sim.ac_sweep_setup(10@u_Hz, 1@u_GHz, 20, 'decade', True)\ntrans_sim.do_ac_sim()\ntrans_sim.ac_resultsNB_DF.columns\n\n\n# In[53]:\n\n\npar_data=ac_representation_tool(trans_sim.ac_resultsNB_DF)\npar_data.make_mag_phase()\n\n\n# In[54]:\n\n\npar_data.ac_sim_mag_DF.columns\n\n\n# In[55]:\n\n\npar_plot=eecomplex_plot_templets()\nfig, [axmag, axphase]=plt.subplots(ncols=1, nrows=2)\npar_plot.bode_plot_two_templet(par_data.ac_sim_mag_DF.index, \n                               par_data.ac_sim_mag_DF['In_[V][dB]'], par_data.ac_sim_phase_DF['In_[V][deg]'],\n                              axs=[axmag, axphase], title='Par Currents')\n\naxmag.semilogx(par_data.ac_sim_mag_DF.index, par_data.ac_sim_mag_DF['Out_[V][dB]'], label='Out')\naxphase.semilogx(par_data.ac_sim_mag_DF.index, par_data.ac_sim_phase_DF['Out_[V][deg]'], label='Out')\n\naxmag.legend(); axphase.legend()\nplt.tight_layout()\n\n\n# In[56]:\n\n\npar_plot=eecomplex_plot_templets()\nfig, [axmag, axphase]=plt.subplots(ncols=1, nrows=2)\npar_plot.bode_plot_two_templet(par_data.ac_sim_mag_DF.index, \n                               par_data.ac_sim_mag_DF['V1_[A][dB]'], par_data.ac_sim_phase_DF['V1_[A][deg]'],\n                              axs=[axmag, axphase], title='Par Currents')\n\naxmag.semilogx(par_data.ac_sim_mag_DF.index, par_data.ac_sim_mag_DF['Vamm_load_[A][dB]'], label='Out')\naxphase.semilogx(par_data.ac_sim_mag_DF.index, par_data.ac_sim_phase_DF['Vamm_load_[A][deg]'], label='Out')\n\naxmag.legend(); axphase.legend()\nplt.tight_layout()\n\n\n# ## Anti-Parallel Primary and Secondary configuration\n# \n# Need to verify this better with a transient simulation.\n\n# In[57]:\n\n\ntransformer=basic_xspice_transformer(prim_turns=2, sec_turns=5, parallel=False)\n\n\n# In[58]:\n\n\nreset()\n#create the nets\nnet_in=Net('In'); net_out=Net('Out')\n\n#create a 1V AC test source and dummy R and attache to nets\nvs=SINEV(ac_magnitude=1@u_V)\nrdummy=R(ref='dummy', value=0@u_Ohm)\nvs['p', 'n']+=rdummy[1], gnd\nrdummy[2]+=net_in\n\n\n#conenct the subcircuit\ntransformer.SKiDl(net_in, gnd, net_out, gnd)\n\n#create a load\nrload=R(ref='load', value=100@u_Ohm)\nload_amm=V(ref='amm_load', dc_value=0)\nnet_in & rload & load_amm & gnd\n\ncirc=generate_netlist(libs=\"SpiceLib\")\nprint(circ)\n\n\n# In[59]:\n\n\ntrans_sim=ac_ease(circ)\ntrans_sim.ac_sweep_setup(10@u_Hz, 1@u_GHz, 20, 'decade', True)\ntrans_sim.do_ac_sim()\ntrans_sim.ac_resultsNB_DF.columns\n\n\n# In[60]:\n\n\nantipar_data=ac_representation_tool(trans_sim.ac_resultsNB_DF)\nantipar_data.make_mag_phase()\n\n\n# In[61]:\n\n\nantipar_data.ac_sim_mag_DF.columns\n\n\n# In[62]:\n\n\npar_plot=eecomplex_plot_templets()\nfig, [axmag, axphase]=plt.subplots(ncols=1, nrows=2)\npar_plot.bode_plot_two_templet(antipar_data.ac_sim_mag_DF.index, \n                               antipar_data.ac_sim_mag_DF['In_[V][dB]'], antipar_data.ac_sim_phase_DF['In_[V][deg]'],\n                              axs=[axmag, axphase], title='Anti-Par Voltages')\n\naxmag.semilogx(antipar_data.ac_sim_mag_DF.index, antipar_data.ac_sim_mag_DF['Out_[V][dB]'], label='Out')\naxphase.semilogx(antipar_data.ac_sim_mag_DF.index, antipar_data.ac_sim_phase_DF['Out_[V][deg]'], label='Out')\n\naxmag.legend(); axphase.legend()\nplt.tight_layout()\n\n\n# In[63]:\n\n\npar_plot=eecomplex_plot_templets()\nfig, [axmag, axphase]=plt.subplots(ncols=1, nrows=2)\npar_plot.bode_plot_two_templet(antipar_data.ac_sim_mag_DF.index, \n                               antipar_data.ac_sim_mag_DF['V1_[A][dB]'], antipar_data.ac_sim_phase_DF['V1_[A][deg]'],\n                              axs=[axmag, axphase], title='Anti-Par Currents')\n\naxmag.semilogx(antipar_data.ac_sim_mag_DF.index, antipar_data.ac_sim_mag_DF['Vamm_load_[A][dB]'], label='Out')\naxphase.semilogx(antipar_data.ac_sim_mag_DF.index, antipar_data.ac_sim_phase_DF['Vamm_load_[A][deg]'], label='Out')\n\naxmag.legend(); axphase.legend()\nplt.tight_layout()\n\n\n# ## Autotransformer\n\n# ## Isolation \n\n# https://www.allaboutcircuits.com/technical-articles/transformer-isolation/\n\n# ### Test Bench Type\n\n# ### Medical Type\n\n# ## Multi Winding\n\n# ## Cinter-tapped\n\n# ## Current Transformer\n\n# ## Y-Delta Converters\n\n# # Citations\n\n# [1] ALL ABOUT ELECTRONICS. \"Self Inductance and Mutual Inductance Explained,\" YouTube, Feb 12, 2017. [Video file]. Available: https://youtu.be/hoTInTKij0o. [Accessed: Jul 18, 2021].\n# \n# [2] ALL ABOUT ELECTRONICS. \"Dot Convention in Magnetically Coupled Circuits,\" YouTube, Feb 18, 2017. [Video file]. Available: https://youtu.be/sILgO4sQmRs. [Accessed: Jul 18, 2021].\n# \n# [3] ALL ABOUT ELECTRONICS. \"Mutually Coupled Inductors in Series (Derivation / Proof and Examples),\" YouTube, Apr 21, 2017. [Video file]. Available: https://youtu.be/49OL_3L7BFA. [Accessed: Jul 18, 2021].\n# \n# [4] ALL ABOUT ELECTRONICS. \"Mutually Coupled Inductors in Parallel (Derivation / Proof and Examples),\" YouTube, Apr 24, 2017. [Video file]. Available: https://youtu.be/NacczEJj_iI. [Accessed: Jul 18, 2021].\n# \n# [5] B. Razavi, \"The Bridged T-Coil [A Circuit for All Seasons]\", IEEE Solid-State Circuits Magazine, vol. 7, no. 4, pp. 9-13, 2015. Available: 10.1109/mssc.2015.2474258 [Accessed 27 January 2021] or https://www.seas.ucla.edu/brweb/papers/Journals/BRFall15TCoil.pdf [Accessed: Jul 18, 2021].\n# \n# [6] Jordan Edmunds. \"Bridged T Coil Analysis Part 1 ,\" YouTube, Feb 23, 2018. [Video file]. Available: https://youtu.be/-kSSMOAhlwU. [Accessed: Jul 18, 2021].\n# \n# [7] Jordan Edmunds. \"Bridged T Coil Analysis Part 2 ,\" YouTube, Feb 23, 2018. [Video file]. Available: https://youtu.be/vr2oYehKC8Q. [Accessed: Jul 18, 2021].\n# \n# [8] Vogt, M. Hendrix and P. Nenzi, Ngspice User’s Manual Version 32 (Describes ngspice release version), 32nd ed. 2020, Chapter 12: Mixed-Mode and Behavioral Modeling with XSPICE.\n# \n", "meta": {"hexsha": "92d2869bce68f8ee47dc604b1b1ff7543d5b67d5", "size": 50548, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/AC_2/AC_3_CoupledMag.py", "max_stars_repo_name": "PyLCARS/Python-and-SPICE-Book", "max_stars_repo_head_hexsha": "0bf02aa16d97115cea955d33a7aab7e02f8d3453", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-01-04T23:56:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-22T13:22:30.000Z", "max_issues_repo_path": "_build/jupyter_execute/AC_2/AC_3_CoupledMag.py", "max_issues_repo_name": "PyLCARS/Python-and-SPICE-Book", "max_issues_repo_head_hexsha": "0bf02aa16d97115cea955d33a7aab7e02f8d3453", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/AC_2/AC_3_CoupledMag.py", "max_forks_repo_name": "PyLCARS/Python-and-SPICE-Book", "max_forks_repo_head_hexsha": "0bf02aa16d97115cea955d33a7aab7e02f8d3453", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.7887700535, "max_line_length": 2259, "alphanum_fraction": 0.6610152726, "include": true, "reason": "import numpy,from scipy,import sympy", "num_tokens": 14558, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3738758227716966, "lm_q2_score": 0.1403362422992606, "lm_q1q2_score": 0.05246832805432423}}
{"text": "![Callysto.ca Banner](https://github.com/callysto/curriculum-notebooks/blob/master/callysto-notebook-banner-top.jpg?raw=true)\n\n<a href=\"https://hub.callysto.ca/jupyter/hub/user-redirect/git-pull?repo=https%3A%2F%2Fgithub.com%2Fcallysto%2Fcurriculum-notebooks&branch=master&subPath=Science/LightOpticalSystems/light-optical-systems.ipynb&depth=1\" target=\"_parent\"><img src=\"https://raw.githubusercontent.com/callysto/curriculum-notebooks/master/open-in-callysto-button.svg?sanitize=true\" width=\"123\" height=\"24\" alt=\"Open in Callysto\"/></a>\n\nimport matplotlib.pyplot as plt\nimport plotly as py\nimport plotly.graph_objs as go\nimport numpy as np\nimport math\nimport ipywidgets as widgets\nfrom IPython.display import display, Math, Latex, HTML, IFrame\nfrom astropy.table import Table, Column\nfrom ipywidgets import interact, interactive\n\npy.offline.init_notebook_mode(connected=True)\n%matplotlib inline\n\nfont = {'family' : 'sans-serif',\n        'weight' : 'normal',\n        'size'   : 14}\n\nplt.rc('font', **font)\n\n'''Above, we are importing all the necessary modules in order to run the notebook. \nNumpy allows us to define arrays of values for our variables to plot them\nmatplotlib is what we use to create the figures\nthe display and widgets are to make the notebook look neat\n'''\n\nHTML('''<script>\n  function code_toggle() {\n    if (code_shown){\n      $('div.input').hide('500');\n      $('#toggleButton').val('Show Code')\n    } else {\n      $('div.input').show('500');\n      $('#toggleButton').val('Hide Code')\n    }\n    code_shown = !code_shown\n  }\n  \n  $( document ).ready(function(){\n    code_shown=false;\n    $('div.input').hide()\n  });\n</script>\n<form action=\"javascript:code_toggle()\"><input type=\"submit\" id=\"toggleButton\" value=\"Show Code\"></form>''')\n        \n    \n\n\n***\n# Light and Optics\n***\n\n<img src=\"https://media.giphy.com/media/3o7OsM9vKFH2ESl0KA/giphy.gif\" alt=\"Drawing\" style=\"width: 600px;\"/>\n<center>Gif taken from https://giphy.com/gifs/fandor-sun-eclipse-3o7OsM9vKFH2ESl0KA/links, August 1st, 2018.</center>\n<center> Figure 1: For hundreds of years, scientists have tried to understand the nature of light. With advances in technology, and inventions like telescopes, we have been able to see farther than ever before. </center> \n\n***\n\n## Introduction\n\nThroughout most of history, humans did not understand light as we do today. As science and technology have progressed over time, so too has our knowledge of the nature of light. \n\nIn this lesson, when we say the word \"light\", we will be referring to visible light (light that comes from the sun, lightbulbs etc.). We will go over how a few key experiments kickstarted a new way of thinking, and a few of the ways that we are able to manipulate light. We will also talk about how our eyes enable us to see.\n\n## Background\n\nIf you had to describe to someone what light is, you may have a hard time. Some people think of light as the absence of darkness, but even that doesn't say much about light itself.\n\nOur understanding of light truly began around the 17th century, when a few individuals started to realize that light was not a mystical substance. Scientists (or \"natural philosophers\", as they were called during that time) recognized that certain properties of light were measurable, and that some properties could be manipulated. Sir Isaac Newton and Ole Rømer were among the first scientists to take a step in this direction.\n\n\n> ### Isaac Newton's Prism Experiment\n\nSir Isaac Newton has made contributions to many fields of science and mathematics. In 1666, while spending time at his childhood home in Lincolnshire, England, Newton began experimenting with light. \n\nUsing a small slit in his window shutters, Newton passed a narrow beam of sunlight through a glass prism. The light travelled through the prism, and projected a rainbow of color on the other side!\n\n<img src=\"http://media.web.britannica.com/eb-media/10/7710-050-36C066AC.jpg\" >\n\n<center>Picture taken from http://media.web.britannica.com/eb-media/10/7710-050-36C066AC.jpg.</center>\n<center> Figure 2: This picture shows how a prism can create a spectrum of color. This is what Newton would have seen in 1666.</center>\n\nLater on, scientists determined that the prism was actually splitting light into its component parts. This phenomenon is called **dispersion**.\n\nThrough this experiment, Newton demonstrated that white light was actually made up of all the individual colors of the rainbow!\n\n> ### Ole Rømer and the Speed of Light\n\nFor many years, people thought that if somebody lit a match, the light from that match would be instantly visible to everyone, no matter how far away they were. However, in 1676 Ole Rømer proved that this is not the case.\n\nRømer spent a long time studying the orbit of Io, one of Jupiter's moons. As part of his study, he began predicting the times when Io should be hidden behind Jupiter's shadow (these periods are called eclipses). However, Rømer saw that his predictions for when these eclipses should occur were not always accurate. \n\n<img src=\"https://media.giphy.com/media/DXIa1beDspYRy/giphy.gif\" alt=\"Drawing\" style=\"width: 300px;\"/>\n<center>Gif taken from https://giphy.com/gifs/timelapse-DXIa1beDspYRy, August 1st, 2018.</center>\n<center> Figure 3: Here we can see Jupiter as it looks through a telescope. You might be able to see a black spot move from the left to the right across Jupiter's surface. This is actually one of Jupiter's many moons!</center> \n\nRømer then realized that these errors may be because the distance between Io and the Earth was always changing. Rømer thought that when the distance between Io and the Earth increased, it might take a longer time for light coming from Io to reach Earth. If this were the case, then the light must be travelling at a finite speed!\n\nAfter taking many measurements and using some clever mathematics, Rømer calculated the speed of light to be roughly 220,000,000 m/s, or 792,000,000 km/h.\n\nToday, we have measured the speed of light to be 299,792,458 m/s. Although he was not exactly right, Rømer provided one of the first mathematical calculations for the speed of light. \n\n***\nSince the time of Rømer and Newton, scientists have made many new discoveries about the nature of light. While not all of these discoveries agree with one another, here are two things we know for sure:\n- Light is made up of a spectrum of color\n- Light travels at a speed of 299,792,458 m/s\n\nNow let's talk about some of the ways we can manipulate light.\n***\n\n## Reflection\n\nWe are all familiar with reflection; chances are, you look at your reflection more than once a day. But have you ever stopped to wonder what is really going on? \n\nReflection is the term used to describe how light can change direction when it comes into contact with certain surfaces. \n\nWhen incoming light rays encounter a reflective surface, they bounce off the surface and continue moving in a new direction. The new direction in which it moves is determined by the **law of reflection**.\n\n\\begin{equation} \n\\rm Law\\: of\\: Reflection: Angle\\: of\\: Incidence = Angle\\: of\\: Reflection\n\\end{equation}\n\nOn the animation below, click on the flashlight to turn it on, and move your mouse to change the angle of incidence.\n\n#IFrame('Animations/reflect.html',width=500,height=320)\n\n%%html\n<iframe src='Animations/reflect.html' width=500 height=350></iframe>\n\n\nAs seen above, the **normal** is what we call the line that forms a 90$^{\\circ}$ angle with  the surface. The **angle of incidence** is what we call the angle between the flash lights beam and the normal. Similarly, the **angle of reflection** is the angle that the newly reflected light beam makes with the normal. The law of reflection states that these two angles will always be equal.\n\n\n\n## Refraction\n\nHave you ever tried to reach down and grab an object sitting at the bottom of a pool of water? If you have, you may have noticed that the object isn't actually in the location that you thought it was.\n\n<img src=\"http://legacy.sciencelearn.org.nz/var/sciencelearn/storage/images/contexts/light-and-sight/sci-media/video/refraction/668954-1-eng-NZ/Refraction.jpg\" alt=\"Drawing\" style=\"width: 450px;\"/>\n<center> Image taken from http://legacy.sciencelearn.org.nz/Contexts/Light-and-Sight/Sci-Media/Video/Refraction/(quality)/hi on August 3rd, 2018.</center>\n<center> Figure 4: When you are looking into a body of water from above, the objects you see beneath the surface are not actually where they appear to be. </center>\n\nThis phenomenon occurs because the light travelling to your eyes from the bottom of the pool **refracts**, or changes its direction of travel, when it transitions from water to air. \n\nThe **index of refraction** is a value that we use to show how much light will bend when travelling through a substance. For example, the index of refraction for air is approximately 1.00, and the index of refraction for water is about 1.33. Because these indexes are different, light will bend when passing from water to air, or vice versa.\n\nUse the animation below to see how light refracts when passing from air to water. Click on the flashlight to turn it on.\n\n#IFrame('Animations/refract.html',width=520,height=320)\n\n%%html\n<iframe src='Animations/refract.html' width=520 height=320></iframe>\n\n\nMathematically, reflection can be described using the following equation, known as Snell's Law:\n\n\\begin{equation} \n\\textrm{Snells Law:}\\: n_1\\sin(\\theta_1) = n_2\\sin(\\theta_2)\n\\end{equation}\n\nwhere $n_1$ is the index of refraction for the first medium, $\\theta_1$ is the incident angle, $n_2$ is the index of refraction for the second medium, and $\\theta_2$ is the angle of refraction.\n\nLight will bend *towards* the normal when travelling from a medium with a *lower* index of refraction to one with a *higher* index of refraction, and vice versa.\n\n***\nSome of the most beautiful sights in nature are caused by reflection and refraction. Here are a couple of examples:\n\n### Rainbows\n\nRainbows are a result of both reflection and refraction. As its raining, each water droplet acts like a tiny prism, just like the one we saw in Figure 2. The water droplets split visible light into colors, and these colors are then reflected back towards our eyes. \n\n<img src=\"http://waterstories.nestle-waters.com/wp-content/uploads/2015/04/How-rainbow-forms-waterstories.jpg\" alt=\"Drawing\" style=\"width: 400px;\"/>\n<center> Image taken from https://waterstories.nestle-waters.com/environment/how-does-a-rainbow-form/ on August 3rd, 2018.</center>\n<center> Figure 5: Water droplets use reflection and refraction to create the beautiful rainbows that we see while it is raining.</center>\n\n\n\n### Mirages\n\nHave you ever been driving on a sunny day, and up ahead it looks as though a stream of water is running across the road? You are really seeing a mirage.\nMirages also occur because of refraction, but they do not result in a display of color like a rainbow. This type of refraction occurs due to a difference in temperature between separate layers of air.\n\nAs we were describing before, refraction occurs when light travels from one substance to another. Well, it turns out that hot air and cold air are actually different enough to act as different substances. Therefore, light will refract when passing through one to the other. \n\n<img src=\"http://edex.s3-us-west-2.amazonaws.com/styles/kraken_optimized/s3/banner-mirage.jpg?itok=YXSTIo8_\" alt=\"Drawing\" style=\"width: 400px;\"/>\n<center> Image taken from https://edexcellence.net/articles/what-the-mirage-gets-wrong-on-teacher-development on August 3rd, 2018.</center>\n<center> Figure 6: Although it may look like water running across the road, it is actually a mirage. These commonly occur in desert areas, where the road can become very hot.</center>\n\nWhen you are looking at a mirage, it can look as though the air is wavy and fluid, which is why it is common to think that you are looking at water. This appearance occurs when layers of hot and cold air are mixing together, and light passing through these layers is constantly being refracted in different directions.\n\nYou may see a mirage appear on top of a hot roadway, behind the exhaust pipe of a plane or car, or around any other source of heat.\n\n## Applications of Reflection and Refraction\n\n### Lenses\n\nIf you have glasses, or contact lenses, then you are constantly using refraction in order to help you see! Lenses use refraction to point light in specific directions.\n\nGenerally speaking, there are two types of lenses: **convex** and **concave**.\n\nTo see how each type of lens affects light, use the following animation.\n\n#IFrame('Animations/convex.html',width=520,height=420)\n\n%%html\n<iframe src='Animations/convex.html' width=520 height=430></iframe>\n\n\nAs seen above, a convex lens focuses light towards a specific point, while a concave lens will spread light away from a point. These lenses can be combined in many ways in order to produce different effects. For example, a camera lens uses a series of both convex and concave lenses in order to direct incoming light towards the back of the camera.\n\n<img src=\"http://i.imgur.com/IH2ymaj.jpg\" alt=\"Drawing\" style=\"width: 400px;\"/>\n<center> Image taken from https://www.reddit.com/r/pic/comments/3o3b7w/camera_lens_cut_in_half/ on August 3rd, 2018.</center>\n<center> Figure 5: This is what the inside of a camera lens looks like. The photographer can adjust how they want the picture to look by changing the distance between the individual lenses.</center>\n\n\n\n\n## Vision\n\nOur eyes are very complex organs, but the process that enables us to see is actually pretty simple. The basic steps are as follows:\n\n1. Light enters the eye through the **pupil**\n2. The convex **lens** behind the pupil directs incoming light towards the **retina**, which is like a screen at the back of our eye.\n3. The retina then sends this image to the brain.\n4. The brain then interprets the image. \n\n<img src=\"https://openclipart.org/image/2400px/svg_to_png/261647/EyeDiagram.png\" alt=\"Drawing\" style=\"width: 400px;\"/>\n<center> Image taken from https://openclipart.org/detail/261647/eye-diagram on August 3rd, 2018. </center>\n<center> Figure 6: This diagram shows some of the key components of the eye that enable us to see.</center>\n\nHowever, the image that is projected onto the retina is actually upside down! \n\n<img src=\"https://m.eet.com/media/1077748/max-hfield-01.gif\" alt=\"Drawing\" style=\"width: 400px;\"/>\n<center> Image taken from https://www.eetimes.com/author.asp?section_id=14&doc_id=1282795 on August 3rd, 2018.</center>\n<center> Figure 7: The convex lens at the front of our eye actually flips images upside down.</center>\n\nSo the retina actually sends an upside down image to the brain, and the brain automatically flips the image rightside up.\n\nUse the following link to see an animation showing how a convex lens flips images upside down:https://phet.colorado.edu/sims/geometric-optics/geometric-optics_en.html.\n\n\n## Technology & Inventions\n\n### The Telescope\n\nThe first telescope was made by Hans Lippershey in 1608, but it was Galileo Galilee who became famous by using it for astronomy. There are many different types of telescopes, but they all use reflection and refraction to make far away objects appear closer.\n\nA telescope uses a large opening to collect incoming light, and then directs this light towards your eye by using mirrors and lenses.\n\n<img src=\"https://www.skyandtelescope.com/wp-content/uploads/three-scopes.jpg\" alt=\"Drawing\" style=\"width: 400px;\"/>\n<center> Image taken from https://www.skyandtelescope.com/press-releases/tips-for-first-time-telescope-buyers/ on August 3rd, 2018.</center>\n<center> Figure 8: Telescopes come in many different shapes and sizes.</center>\n\nThe reason why things look bigger when looking through a telescope is because of the lenses.\n\n\n### The Microscope\n\n\n- talk about invention of microscope\n- why it works\n\n\n## Conclusion\n\nOur understanding of light is the result of hundreds of years of research and innovation. Along the way, we have created incredible new technologies that have allowed us to look further than ever before.\n\n<img src=\"https://xenlife.com.au/wp-content/uploads/Hubble-Space-Telescope-650x250-1078x516.jpg\" alt=\"Drawing\" style=\"width: 400px;\"/>\n<center> Image taken from https://xenlife.com.au/hubble-space-telescope-important/ on August 3rd, 2018.</center>\n<center> Figure 9: The Hubble Space Telescope has shown us pictures of galaxies that are billions of light years away.</center>\n \n\n\n\n[![Callysto.ca License](https://github.com/callysto/curriculum-notebooks/blob/master/callysto-notebook-banner-bottom.jpg?raw=true)](https://github.com/callysto/curriculum-notebooks/blob/master/LICENSE.md)", "meta": {"hexsha": "8e26369e18b42a51cc19b2d902b9312c629fe0ed", "size": 16685, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/curriculum-notebooks/Science/LightOpticalSystems/light-optical-systems.py", "max_stars_repo_name": "BryceHaley/curriculum-jbook", "max_stars_repo_head_hexsha": "d1246799ddfe62b0cf5c389394a18c2904383437", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-18T18:19:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T18:19:40.000Z", "max_issues_repo_path": "_build/jupyter_execute/curriculum-notebooks/Science/LightOpticalSystems/light-optical-systems.py", "max_issues_repo_name": "callysto/curriculum-jbook", "max_issues_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/curriculum-notebooks/Science/LightOpticalSystems/light-optical-systems.py", "max_forks_repo_name": "callysto/curriculum-jbook", "max_forks_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 60.0179856115, "max_line_length": 428, "alphanum_fraction": 0.7691938867, "include": true, "reason": "import numpy,from astropy", "num_tokens": 4019, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4035668537353746, "lm_q2_score": 0.12940274334274965, "lm_q1q2_score": 0.05222265799555967}}
{"text": "import pandas as pd\nimport numpy as np\nfrom six import string_types\n\n\n# From Penguoin Utils.py\n\ndef _export_table(table, fname):\n    \"\"\"Export DataFrame to .csv\"\"\"\n    import os.path as op\n    extension = op.splitext(fname.lower())[1]\n    if extension == '':\n        fname = fname + '.csv'\n    table.to_csv(fname, index=None, sep=',', encoding='utf-8',\n                 float_format='%.4f', decimal='.')\n    \ndef reshape_data(df, id, dv='DV', rm='Time'):\n    \"\"\"Reshape data from human-readable to analysis shape\n\n    See: https://deparkes.co.uk/2016/10/28/reshape-pandas-data-with-melt/\n\n    Parameters\n    ----------\n    df : DataFrame\n        Dataframe in original shape\n    id : string\n        Column to use as identifier variables. (e.g. \"Subjects\")\n    dv : string\n        Name of the dependant variables (e.g. \"DV\" or \"Scores\")\n    rm : string\n        Name of the measurements (e.g. \"Time\" or \"Weekday\")\n\n    Returns\n    -------\n    df_reshaped : DataFrame\n        Reshaped DataFrame\n\n    Examples\n    --------\n\n    Human-readable:\n\n    *Values represent scores at a cognitive test at different times of the day.\n    Ss = subject*::\n\n        Ss    10am  2pm   6pm\n        1     3.5   3.2   2.8\n        2     2.1   2.4   2.8\n\n    Pingouin::\n\n        Ss    Score    Time\n        1     3.5      10am\n        1     3.2      2pm\n        1     2.8      6pm\n        2     2.1      10am\n        2     2.4      2pm\n        2     2.8      6pm\n\n    >>> import pandas as pd\n    >>> from pingouins import reshape_data\n    >>> data = {'Ss': [1, 2, 3],\n    >>>        '10am': [12, 6, 5],\n    >>>        '2pm': [10, 6, 11],\n    >>>        '6pm': [8, 5, 7]}\n    >>> df = pd.DataFrame(data, columns=['Ss', '10am', '2pm', '6pm'])\n    >>> reshaped = reshape_data(df, 'Ss', dv=\"Score\", rm=\"Time\")\n    >>> print(reshaped)\n        Ss  Time  Score\n        1   10am  12\n        1   2pm   10\n        1   6pm   8\n        2   10am  6\n        2   2pm   6\n        2   6pm   5\n        3  10am   5\n        3   2pm   11\n        3   6pm   7\n    \"\"\"\n    return pd.melt(df, id_vars=id, var_name=rm, value_name=dv).sort_values(\n        by=id)\n\n\ndef _remove_na(x, y, paired=False):\n    \"\"\"Remove missing values in paired and independant measurements.\n    \"\"\"\n    x_na = np.any(np.isnan(x))\n    y_na = np.any(np.isnan(y))\n    if (x_na or y_na) and paired:\n        ar = np.c_[x, y]\n        ar = ar[~np.isnan(ar).any(axis=1)]\n        x, y = ar[:, 0], ar[:, 1]\n    elif (x_na or y_na) and not paired:\n        x = np.array(list(filter(lambda v: v == v, x))) if x_na else x\n        y = np.array(list(filter(lambda v: v == v, y))) if y_na else y\n    return x, y\n\n\ndef _remove_rm_na(dv=None, within=None, data=None):\n    \"\"\"Remove subject(s) with one or more missing values in repeated\n    measurements.\n    \"\"\"\n    rm = list(data[within].dropna().unique())\n    n_rm = len(rm)\n    n_obs = int(data.groupby(within)[dv].count().max())\n    data['ID_Subj'] = np.tile(np.arange(n_obs), n_rm)\n\n    # Efficiently remove subjects with one or more missing values\n    data = data.set_index('ID_Subj')\n\n    # Find index with nan\n    iloc_nan = pd.isnull(data).any(1).nonzero()[0]\n    idx_nan = data.index[iloc_nan].values\n    print('\\nNote: %i subject(s) removed because of missing value(s).\\n'\n          % len(idx_nan))\n    return data.drop(idx_nan).reset_index(drop=True)\n\n\ndef _check_eftype(eftype):\n    \"\"\"Check validity of eftype\"\"\"\n    if eftype.lower() in ['none', 'hedges', 'cohen', 'glass', 'r',\n                          'eta-square', 'odds-ratio', 'auc']:\n        return True\n    else:\n        return False\n\n\ndef _check_dataframe(dv=None, between=None, within=None, effects=None,\n                     data=None):\n    \"\"\"Check dataframe\"\"\"\n    # Check input arguments\n    if not isinstance(data, pd.DataFrame):\n        raise ValueError('Data must be a pandas dataframe')\n    if any(v is None for v in [dv, data]):\n        raise ValueError('DV and data must be specified')\n    if effects not in ['within', 'between', 'interaction', 'all']:\n        raise ValueError('Effects must be: within, between, interaction, all')\n    if effects == 'within' and not isinstance(within, string_types):\n        raise ValueError('within must be specified when effects=within')\n    elif effects == 'between' and not isinstance(between, string_types):\n        raise ValueError('between must be specified when effects=between')\n    elif effects == 'interaction':\n        for input in [within, between]:\n            if not isinstance(input, string_types):\n                raise ValueError('within and between must be specified when \\\n                effects=interaction')\n\n\ndef _extract_effects(dv=None, between=None, within=None, effects=None,\n                     data=None):\n    \"\"\"Extract main effects\"\"\"\n    # Check the dataframe\n    _check_dataframe(dv=dv, between=between, within=within, effects=effects,\n                     data=data)\n\n    datadic = {}\n    nobs = np.array([], dtype=int)\n\n    # Extract number of pairwise comparisons\n    if effects.lower() in ['within', 'between']:\n        col = within if effects == 'within' else between\n        # Extract data\n        labels = list(data[col].unique())\n        for l in labels:\n            datadic[l] = data[data[col] == l][dv]\n            nobs = np.append(nobs, len(datadic[l]))\n\n    elif effects.lower() == 'interaction':\n        labels_with = list(data[within].unique())\n        labels_betw = list(data[between].unique())\n        for lw in labels_with:\n            for l in labels_betw:\n                tmp = data[data[within] == lw]\n                datadic[lw, l] = tmp[tmp[between] == l][dv]\n                nobs = np.append(nobs, len(datadic[lw, l]))\n\n    dt_array = pd.DataFrame.from_dict(datadic)\n    return dt_array, nobs\n\ndef gzscore(x):\n    \"\"\"Geometric standard (Z) score.\n\n    Geometric Z-scores are better measures of dispersion than arithmetic\n    z-scores when the sample data come from a log-normally distributed\n    population.\n\n    See https://en.wikipedia.org/wiki/Geometric_standard_deviation\n\n    Parameters\n    ----------\n    x : array_like\n        Array of raw values\n\n    Returns\n    -------\n    gzscore : array_like\n        Array of geometric z-scores (same shape as x)\n\n    Examples\n    --------\n    Standardize a log-normal array\n\n        >>> import numpy as np\n        >>> from pingouin import gzscore\n        >>> np.random.seed(123)\n        >>> raw = np.random.lognormal(size=100)\n        >>> print(raw.mean().round(3), raw.std().round(3))\n            1.849 2.282\n        >>> z = gzscore(raw)\n        >>> print(z.mean(), z.std())\n            0 0.995\n    \"\"\"\n    from scipy.stats import gmean\n    # Geometric mean\n    geo_mean = gmean(x)\n    # Geometric standard deviation\n    gstd = np.exp(np.sqrt(np.sum((np.log(x / geo_mean))**2) / (len(x) - 1)))\n    # Geometric z-score\n    return np.log(x / geo_mean) / np.log(gstd)\n\n\ndef test_normality(*args, alpha=.05):\n    \"\"\"Test the normality of one or more array.\n\n    Parameters\n    ----------\n    sample1, sample2,... : array_like\n        Array of sample data. May be different lengths.\n\n    Returns\n    -------\n    normal : boolean\n        True if x comes from a normal distribution.\n    p : float\n        P-value.\n\n    See Also\n    --------\n    test_homoscedasticity : Test equality of variance.\n    test_sphericity : Mauchly's test for sphericity.\n\n    Examples\n    --------\n    1. Test the normality of one array.\n\n        >>> import numpy as np\n        >>> from pingouin import test_normality\n        >>> np.random.seed(123)\n        >>> x = np.random.normal(size=100)\n        >>> normal, p = test_normality(x, alpha=.05)\n        >>> print(normal, p)\n        True 0.27\n\n    2. Test the normality of two arrays.\n\n        >>> import numpy as np\n        >>> from pingouin import test_normality\n        >>> np.random.seed(123)\n        >>> x = np.random.normal(size=100)\n        >>> y = np.random.rand(100)\n        >>> normal, p = test_normality(x, y, alpha=.05)\n        >>> print(normal, p)\n        [True   False] [0.27   0.0005]\n    \"\"\"\n    from scipy.stats import shapiro\n    k = len(args)\n    p = np.zeros(k)\n    normal = np.zeros(k, 'bool')\n    for j in range(k):\n        _, p[j] = shapiro(args[j])\n        normal[j] = True if p[j] > alpha else False\n\n    if k == 1:\n        normal = bool(normal)\n        p = float(p)\n\n    return normal, p\n\n\ndef test_homoscedasticity(*args, alpha=.05):\n    \"\"\"Test equality of variance.\n\n    If data are normally distributed, uses Bartlett (1937).\n    If data are not-normally distributed, uses Levene (1960).\n\n    Parameters\n    ----------\n    sample1, sample2,... : array_like\n        Array of sample data. May be different lengths.\n\n    Returns\n    -------\n    equal_var : boolean\n        True if data have equal variance.\n    p : float\n        P-value.\n\n    See Also\n    --------\n    test_normality : Test the normality of one or more array.\n    test_sphericity : Mauchly's test for sphericity.\n\n    Examples\n    --------\n    Test the homoscedasticity of two arrays.\n\n        >>> import numpy as np\n        >>> from pingouin import test_homoscedasticity\n        >>> np.random.seed(123)\n        >>> # Scale = standard deviation of the distribution.\n        >>> x = np.random.normal(loc=0, scale=1., size=100)\n        >>> y = np.random.normal(loc=0, scale=0.8,size=100)\n        >>> print(np.var(x), np.var(y))\n            1.27 0.60\n        >>> equal_var, p = test_homoscedasticity(x, y, alpha=.05)\n        >>> print(equal_var, p)\n            False 0.0002\n    \"\"\"\n    from scipy.stats import levene, bartlett\n    k = len(args)\n    if k < 2:\n        raise ValueError(\"Must enter at least two input sample vectors.\")\n\n    # Test normality of data\n    normal, _ = test_normality(*args)\n    if np.count_nonzero(normal) != normal.size:\n        # print('Data are not normally distributed. Using Levene test.')\n        _, p = levene(*args)\n    else:\n        _, p = bartlett(*args)\n\n    equal_var = True if p > alpha else False\n    return equal_var, p\n\n\ndef test_dist(*args, dist='norm'):\n    \"\"\"Anderson-Darling test of distribution.\n\n    Parameters\n    ----------\n    sample1, sample2,... : array_like\n        Array of sample data. May be different lengths.\n    dist : string\n        Distribution ('norm', 'expon', 'logistic', 'gumbel')\n\n    Returns\n    -------\n    from_dist : boolean\n        True if data comes from this distribution.\n    \"\"\"\n    from scipy.stats import anderson\n    k = len(args)\n    from_dist = np.zeros(k, 'bool')\n    sig_level = np.zeros(k)\n    for j in range(k):\n        st, cr, sig = anderson(args[j], dist=dist)\n        from_dist[j] = True if (st > cr).any() else False\n        sig_level[j] = sig[np.argmin(np.abs(st - cr))]\n\n    if k == 1:\n        from_dist = bool(from_dist)\n        sig_level = float(sig_level)\n    return from_dist, sig_level\n\n\ndef test_sphericity(X, alpha=.05):\n    \"\"\"Mauchly's test for sphericity\n\n    https://www.mathworks.com/help/stats/mauchlys-test-of-sphericity.html\n\n    Warning: results can slightly differ than R or Matlab. If you can,\n    always double-check your results.\n\n    Parameters\n    ----------\n    X : array_like\n        Data array of shape (n_observations, n_repetitions)\n    alpha : float, optional\n        Significance level\n\n    Returns\n    -------\n    sphericity : boolean\n        True if data have the sphericity property.\n    W : float\n        Mauchly's W statistic\n    chi_sq : float\n        Chi-square statistic\n    ddof : int\n        Degrees of freedom\n    p : float\n        P-value.\n    eps : float\n        Epsilon adjustment factor.\n\n    See Also\n    --------\n    test_homoscedasticity : Test equality of variance.\n    test_normality : Test the normality of one or more array.\n\n    Examples\n    --------\n    Test the sphericity of an array with 30 observations *\n    3 repeated measures\n\n        >>> import numpy as np\n        >>> from pingouin import test_sphericity\n        >>> np.random.seed(123)\n        >>> x = np.random.normal(loc=0, scale=1., size=30)\n        >>> y = np.random.normal(loc=0, scale=0.8,size=30)\n        >>> z = np.random.normal(loc=0, scale=0.9,size=30)\n        >>> X = np.c_[x, y, z]\n        >>> sphericity, W, chi_sq, ddof, p, eps = test_sphericity(X)\n        >>> print(sphericity, p)\n        True 0.56\n        \"\"\"\n    from scipy.stats import chi2\n    n = X.shape[0]\n\n    # Compute the covariance matrix\n    S = np.cov(X, rowvar=0)\n    p = S.shape[1]\n    d = p - 1\n\n    # Orthonormal contrast matrix\n    C = np.array(np.triu(np.ones((p, d))), order='F')\n    C.reshape(-1, order='F')[1::p + 1] = -np.arange(d)\n    C, _ = np.linalg.qr(C)\n    d = C.shape[1]\n    T = C.T.dot(S).dot(C)\n\n    # Compute epsilon\n    eig = np.linalg.eigvals(T)\n    eps = np.sum(eig) ** 2 / ((S.shape[0] - 1) * np.sum(eig**2))\n    # Alternative:\n    # eps = np.trace(T) ** 2 / ((S.shape[0] - 1) * np.sum(\n    # np.sum(T * T, axis=1)))\n\n    # Mauchly's statistic\n    W = np.linalg.det(T) / (np.trace(T) / (p - 1))**d\n\n    # Chi-square statistic\n    nr = n - np.linalg.matrix_rank(X)\n    dd = 1 - (2 * d**2 + d + 2) / (6 * d * nr)\n    chi_sq = -np.log(W) * dd * nr\n    ddof = d * (d + 1) / 2 - 1\n    pval = chi2.sf(chi_sq, ddof)\n\n    # Second order approximation\n    pval2 = chi2.sf(chi_sq, ddof + 4)\n    w2 = (d + 2) * (d - 1) * (d - 2) * (2 * d**3 + 6 * d * d + 3 * d + 2) / \\\n         (288 * d * d * nr * nr * dd * dd)\n    pval += w2 * (pval2 - pval)\n\n    sphericity = True if pval > alpha else False\n    return sphericity, W, chi_sq, ddof, pval, eps\n\n\ndef ttest(x, y, paired=False, tail='two-sided', correction='auto', r=.707):\n    \"\"\"T-test.\n\n    Parameters\n    ----------\n    x : array_like\n        First set of observations.\n    y : array_like or float\n        Second set of observations. If y is a single value, a one-sample T-test\n        is computed.\n    paired : boolean\n        Specify whether the two observations are related (i.e. repeated\n        measures) or independant.\n    tail : string\n        Specify whether to return two-sided or one-sided p-value.\n    correction : string or boolean\n        For unpaired two sample T-tests, specify whether or not to correct for\n        unequal variances using Welch separate variances T-test. If 'auto', it\n        will automatically uses Welch T-test when the sample sizes are unequal,\n        as recommended by Zimmerman 2004.\n    r : float\n        Cauchy scale factor for computing the Bayes Factor.\n        Smaller values of r (e.g. 0.5), may be appropriate when small effect\n        sizes are expected a priori; larger values of r are appropriate when\n        large effect sizes are expected (Rouder et al 2009).\n        The default is 0.707 (= np.sqrt(2) / 2).\n\n    Returns\n    -------\n    stats : pandas DataFrame\n        T-test summary ::\n\n        'T-val' : T-value\n        'p-val' : p-value\n        'dof' : degrees of freedom\n        'cohen-d' : Cohen d effect size\n        'power' : achieved power of the test ( = 1 - type II error)\n        'BF10' : Bayes Factor of the alternative hypothesis\n\n    Notes\n    -----\n    Missing values are automatically removed from the data. If x and y are\n    paired, the entire row is removed.\n\n    Examples\n    --------\n    1. One-sample T-test.\n\n        >>> from pingouin import ttest\n        >>> x = [5.5, 2.4, 6.8, 9.6, 4.2]\n        >>> ttest(x, 4)\n            T-val   p-val  dof  cohen-d  power   BF10\n            1.397  0.2348    4    0.699  0.226  0.766\n\n    2. Paired two-sample T-test (one-tailed).\n\n        >>> from pingouin import ttest\n        >>> pre = [5.5, 2.4, 6.8, 9.6, 4.2]\n        >>> post = [6.4, 3.4, 6.4, 11., 4.8]\n        >>> ttest(pre, post, paired=True, tail='one-sided')\n            T-val   p-val  dof  cohen-d  power   BF10\n            -2.308   0.04    4     0.28  0.132  1.864\n\n    3. Paired two-sample T-test with missing values.\n\n        >>> from pingouin import ttest\n        >>> from numpy import nan\n        >>> pre = [5.5, 2.4, nan, 9.6, 4.2]\n        >>> post = [6.4, 3.4, 6.4, 11., 4.8]\n        >>> ttest(pre, post, paired=True)\n            T-val    p-val  dof  cohen-d  power    BF10\n            -5.902  0.0097    3   -0.354  0.074  24.926\n\n    4. Independant two-sample T-test (equal sample size).\n\n        >>> from pingouin import ttest\n        >>> import numpy as np\n        >>> np.random.seed(123)\n        >>> x = np.random.normal(loc=7, size=20)\n        >>> y = np.random.normal(loc=4, size=20)\n        >>> ttest(x, y, correction='auto')\n            T-val     p-val  dof  cohen-d  power   BF10\n            9.106  4.30e-11   38     2.88    1.0  1.4e8\n\n    5. Independant two-sample T-test (unequal sample size).\n\n        >>> from pingouin import ttest\n        >>> import numpy as np\n        >>> np.random.seed(123)\n        >>> x = np.random.normal(loc=7, size=20)\n        >>> y = np.random.normal(loc=6.5, size=15)\n        >>> ttest(x, y, correction='auto')\n            T-val     p-val  dof   dof-corr  cohen-d  power   BF10\n            2.327     0.027   33      30.75    0.792  0.614  2.454\n    \"\"\"\n    from scipy.stats import ttest_rel, ttest_ind, ttest_1samp\n    from pingouin import ttest_power, compute_effsize\n    x = np.asarray(x)\n    y = np.asarray(y)\n\n    if x.size != y.size and paired:\n        print('x and y have unequal sizes. Switching to paired == False.')\n        paired = False\n\n    # Remove NA\n    x, y = _remove_na(x, y, paired=paired)\n    nx = x.size\n    ny = y.size\n    stats = pd.DataFrame({}, index=['T-test'])\n\n    if ny == 1:\n        # Case one sample T-test\n        tval, pval = ttest_1samp(x, y)\n        dof = nx - 1\n        pval = pval / 2 if tail == 'one-sided' else pval\n\n    if ny > 1 and paired is True:\n        # Case paired two samples T-test\n        tval, pval = ttest_rel(x, y)\n        dof = nx - 1\n        bf = bayesfactor_ttest(tval, nx, ny, paired=True, r=r)\n\n    elif ny > 1 and paired is False:\n        dof = nx + ny - 2\n        # Case unpaired two samples T-test\n        if correction is True or (correction == 'auto' and nx != ny):\n            # Use the Welch separate variance T-test\n            tval, pval = ttest_ind(x, y, equal_var=False)\n            # dof are approximated using Welch–Satterthwaite equation\n            vx = x.var(ddof=1)\n            vy = y.var(ddof=1)\n            dof_corr = (vx / nx + vy / ny)**2 / ((vx / nx)**2 / (nx - 1) +\n                                                 (vy / ny)**2 / (ny - 1))\n            stats['dof-corr'] = dof_corr\n        else:\n            tval, pval = ttest_ind(x, y, equal_var=True)\n\n    pval = pval / 2 if tail == 'one-sided' else pval\n\n    # Effect size and achieved power\n    d = compute_effsize(x, y, paired=paired, eftype='cohen')\n    power = ttest_power(d, nx, ny, paired=paired, tail=tail)\n\n    # Bayes factor\n    bf = bayesfactor_ttest(tval, nx, ny, paired=paired, tail=tail, r=r)\n\n    # Fill output DataFrame\n    stats['dof'] = dof\n    stats['T-val'] = tval.round(3)\n    stats['p-val'] = pval\n    stats['tail'] = tail\n    stats['cohen-d'] = np.abs(d).round(3)\n    stats['power'] = power\n    stats['BF10'] = bf\n\n    col_order = ['T-val', 'p-val', 'dof', 'dof-corr', 'tail', 'cohen-d',\n                 'power', 'BF10']\n    stats = stats.reindex(columns=col_order)\n    stats.dropna(how='all', axis=1, inplace=True)\n    return stats\n\n\ndef rm_anova(dv=None, within=None, data=None, correction='auto',\n             remove_na=True, detailed=False, export_filename=None):\n    \"\"\"One-way repeated measures ANOVA.\n\n    Results have been tested against R and JASP.\n\n    Parameters\n    ----------\n    dv : string\n        Name of column containing the dependant variable.\n    within : string\n        Name of column containing the within factor.\n    data : pandas DataFrame\n        DataFrame\n    correction : string or boolean\n        If True, return Greenhouse-Geisser corrected p-value.\n        If 'auto' (default), compute Mauchly's test of sphericity to determine\n        whether the p-values needs to be corrected.\n    remove_na : boolean\n        If True, automatically remove from the analysis subjects with one or\n        more missing values::\n\n            Ss    x1       x2       x3\n            1     5.0      4.2      nan\n            2     4.6      3.6      3.9\n\n        In this example, if remove_na == True, Ss 1 will be removed from the\n        ANOVA because of the x3 missing value. If False, the two non-missing\n        values will be included in the analysis.\n    detailed : boolean\n        If True, return a full ANOVA table\n    export_filename : string\n        Filename (without extension) for the output file.\n        If None, do not export the table.\n        By default, the file will be created in the current python console\n        directory. To change that, specify the filename with full path.\n\n    Returns\n    -------\n    aov : DataFrame\n        ANOVA summary ::\n\n        'Source' : Name of the within-group factor\n        'ddof1' : Degrees of freedom (numerator)\n        'ddof2' : Degrees of freedom (denominator)\n        'F' : F-value\n        'p-unc' : Uncorrected p-value\n        'np2' : Partial eta-square effect size\n        'p-GG-corr' : Greenhouse-Geisser corrected p-value\n        'W-Mauchly' : Mauchly statistic\n        'X2-Mauchly' : Chi-square statistic of the Mauchly test\n        'DF-Mauchly' : Degrees of freedom for the Mauchly test\n        'p-Mauchly' : p-value of the Mauchly test\n        'sphericity' : sphericity of the data (boolean)\n\n    See Also\n    --------\n    anova : One-way ANOVA\n    mixed_anova : Two way mixed ANOVA\n    friedman : Non-parametric one-way repeated measures ANOVA\n\n    Notes\n    -----\n    The effect size reported in Pingouin is the partial eta-square.\n    However, one should keep in mind that for one-way repeated-measures ANOVA,\n    partial eta-square is the same as eta-square.\n\n    For more details, see Bakeman 2005; Richardson 2011.\n\n    Examples\n    --------\n    Compute a one-way repeated-measures ANOVA.\n\n        >>> import pandas as pd\n        >>> from pingouin import rm_anova, print_table\n        >>> df = pd.read_csv('dataset.csv')\n        >>> aov = rm_anova(dv='DV', within='Time', data=df, correction='auto',\n                           remove_na=True, detailed=True,\n                           export_filename='rm_anova.csv')\n        >>> print_table(aov)\n    \"\"\"\n    from scipy.stats import f\n    # Check data\n    _check_dataframe(dv=dv, within=within, data=data, effects='within')\n\n    # Remove NaN\n    if remove_na and data[dv].isnull().values.any():\n        data = _remove_rm_na(dv=dv, within=within, data=data)\n\n    # Reset index (avoid duplicate axis error)\n    data = data.reset_index(drop=True)\n\n    # Sort values (to avoid bug when creating 'Subj' column)\n    data = data.sort_values(by=within, kind='mergesort')\n\n    # Groupby\n    grp_with = data.groupby(within)[dv]\n    rm = list(data[within].unique())\n    n_rm = len(rm)\n    n_obs = int(data.groupby(within)[dv].count().max())\n    grandmean = data[dv].mean()\n\n    # Calculate sums of squares\n    sstime = ((grp_with.mean() - grandmean)**2 * grp_with.count()).sum()\n    sswithin = grp_with.apply(lambda x: (x - x.mean())**2).sum()\n    data['Subj'] = np.tile(np.arange(n_obs), n_rm)\n    grp_subj = data.groupby('Subj')[dv]\n    sssubj = n_rm * np.sum((grp_subj.mean() - grandmean)**2)\n    sserror = sswithin - sssubj\n\n    # Calculate degrees of freedom\n    ddof1 = n_rm - 1\n    ddof2 = ddof1 * (n_obs - 1)\n\n    # Calculate F and p-values\n    mserror = sserror / (ddof2 / ddof1)\n    fval = sstime / mserror\n    p_unc = f(ddof1, ddof2).sf(fval)\n\n    # Calculating partial eta-square\n    # Similar to (fval * ddof1) / (fval * ddof1 + ddof2)\n    np2 = sstime / (sstime + sserror)\n\n    # Reshape and remove NAN for sphericity estimation and correction\n    data_pivot = data.pivot(index='Subj', columns=within, values=dv).dropna()\n\n    # Compute sphericity using Mauchly's test\n    # Sphericity assumption only applies if there are more than 2 levels\n    if correction == 'auto' or (correction is True and n_rm >= 3):\n        sphericity, W_mauchly, chi_sq_mauchly, ddof_mauchly, \\\n            p_mauchly, eps = test_sphericity(data_pivot.values, alpha=.05)\n\n        if correction == 'auto':\n            correction = True if not sphericity else False\n    else:\n        correction = False\n\n    # If required, apply Greenhouse-Geisser correction for sphericity\n    if correction:\n        # print('eps = ', eps)\n        corr_ddof1, corr_ddof2 = [np.maximum(d * eps, 1.) for d in\n                                  (ddof1, ddof2)]\n        p_corr = f(corr_ddof1, corr_ddof2).sf(fval)\n\n    # Create output dataframe\n    if not detailed:\n        aov = pd.DataFrame({'Source': within,\n                            'ddof1': ddof1,\n                            'ddof2': ddof2,\n                            'F': fval,\n                            'p-unc': p_unc,\n                            'np2': np2\n                            }, index=[0])\n        if correction:\n            aov['p-GG-corr'] = p_corr\n            aov['W-Mauchly'] = W_mauchly\n            aov['X2-Mauchly'] = chi_sq_mauchly\n            aov['DF-Mauchly'] = ddof_mauchly\n            aov['p-Mauchly'] = p_mauchly\n            aov['sphericity'] = sphericity\n\n        col_order = ['Source', 'ddof1', 'ddof2', 'F', 'p-unc',\n                     'p-GG-corr', 'np2', 'sphericity', 'W-Mauchly',\n                     'X2-Mauchly', 'DF-Mauchly', 'p-Mauchly']\n    else:\n        aov = pd.DataFrame({'Source': [within, 'Error'],\n                            'SS': [sstime, sserror],\n                            'DF': [ddof1, ddof2],\n                            'MS': [sstime / ddof1, sserror / ddof2],\n                            'F': [fval, np.nan],\n                            'p-unc': [p_unc, np.nan],\n                            'np2': [np2, np.nan]\n                            })\n        if correction:\n            aov['p-GG-corr'] = [p_corr, np.nan]\n            aov['W-Mauchly'] = [W_mauchly, np.nan]\n            aov['X2-Mauchly'] = [chi_sq_mauchly, np.nan]\n            aov['DF-Mauchly'] = np.array([ddof_mauchly, 0], 'int')\n            aov['p-Mauchly'] = [p_mauchly, np.nan]\n            aov['sphericity'] = [sphericity, np.nan]\n\n        col_order = ['Source', 'SS', 'DF', 'MS', 'F', 'p-unc', 'p-GG-corr',\n                     'np2', 'sphericity', 'W-Mauchly', 'X2-Mauchly',\n                     'DF-Mauchly', 'p-Mauchly']\n\n    aov = aov.reindex(columns=col_order)\n    aov.dropna(how='all', axis=1, inplace=True)\n    # Export to .csv\n    if export_filename is not None:\n        _export_table(aov, export_filename)\n    return aov\n\n\ndef anova(dv=None, between=None, data=None, detailed=False,\n          export_filename=None):\n    \"\"\"One-way ANOVA.\n\n    Results have been tested against R and JASP.\n\n    Parameters\n    ----------\n    dv : string\n        Name of column containing the dependant variable.\n    between : string\n        Name of column containing the between factor.\n    data : pandas DataFrame\n        DataFrame\n    detailed : boolean\n        If True, return a detailed ANOVA table\n    export_filename : string\n        Filename (without extension) for the output file.\n        If None, do not export the table.\n        By default, the file will be created in the current python console\n        directory. To change that, specify the filename with full path.\n\n    Returns\n    -------\n    aov : DataFrame\n        ANOVA summary ::\n\n        'Source' : name of the between-group factor\n        'ddof1' : degrees of freedom (numerator)\n        'ddof2' : degrees of freedom (denominator)\n        'F' : F-value\n        'p-unc' : uncorrected p-value\n        'np2' : Partial eta-square effect size\n\n    See Also\n    --------\n    rm_anova : One-way repeated measures ANOVA\n    mixed_anova : Two way mixed ANOVA\n    kruskal : Non-parametric one-way ANOVA\n\n\n    Notes\n    -----\n    The effect size reported in Pingouin is the partial eta-square.\n    However, one should keep in mind that for one-way ANOVA\n    partial eta-square is the same as eta-square and generalized eta-square.\n\n    For more details, see Bakeman 2005; Richardson 2011.\n\n    Examples\n    --------\n    Compute a one-way ANOVA.\n\n        >>> import pandas as pd\n        >>> from pingouin import anova, print_table\n        >>> df = pd.read_csv('dataset.csv')\n        >>> aov = anova(dv='DV', between='Group', data=df,\n                        detailed=True, export_filename='anova.csv')\n        >>> print_table(aov)\n    \"\"\"\n    from scipy.stats import f\n\n    # Check data\n    _check_dataframe(dv=dv, between=between, data=data,\n                     effects='between')\n\n    # Reset index (avoid duplicate axis error)\n    data = data.reset_index(drop=True)\n\n    groups = list(data[between].unique())\n    n_groups = len(groups)\n    N = data[dv].size\n\n    # Calculate sums of squares\n    grp = data.groupby(between)[dv]\n    # Between effect\n    ssbetween = ((grp.mean() - data[dv].mean())**2 * grp.count()).sum()\n    # Within effect (= error between)\n    sserror = grp.apply(lambda x: (x - x.mean())**2).sum()\n\n    # Calculate DOF, MS, F and p-values\n    ddof1 = n_groups - 1\n    ddof2 = N - n_groups\n    msbetween = ssbetween / ddof1\n    mserror = sserror / ddof2\n    fval = msbetween / mserror\n    p_unc = f(ddof1, ddof2).sf(fval)\n\n    # Calculating partial eta-square\n    # Similar to (fval * ddof1) / (fval * ddof1 + ddof2)\n    np2 = ssbetween / (ssbetween + sserror)\n\n    # Create output dataframe\n    if not detailed:\n        aov = pd.DataFrame({'Source': between,\n                            'ddof1': ddof1,\n                            'ddof2': ddof2,\n                            'F': fval,\n                            'p-unc': p_unc,\n                            'np2': np2\n                            }, index=[0])\n\n        col_order = ['Source', 'ddof1', 'ddof2', 'F', 'p-unc', 'np2']\n    else:\n        aov = pd.DataFrame({'Source': [between, 'Within'],\n                            'SS': [ssbetween, sserror],\n                            'DF': [ddof1, ddof2],\n                            'MS': [msbetween, mserror],\n                            'F': [fval, np.nan],\n                            'p-unc': [p_unc, np.nan],\n                            'np2': [np2, np.nan]\n                            })\n        col_order = ['Source', 'SS', 'DF', 'MS', 'F', 'p-unc', 'np2']\n\n    aov = aov.reindex(columns=col_order)\n    aov.dropna(how='all', axis=1, inplace=True)\n    # Export to .csv\n    if export_filename is not None:\n        _export_table(aov, export_filename)\n    return aov\n\n\ndef mixed_anova(dv=None, within=None, between=None, data=None,\n                correction='auto', remove_na=True, export_filename=None):\n    \"\"\"Mixed-design (split-plot) type II ANOVA.\n\n    Results have been tested against R and JASP.\n\n    Parameters\n    ----------\n    dv : string\n        Name of column containing the dependant variable.\n    within : string\n        Name of column containing the within factor.\n    between : string\n        Name of column containing the between factor.\n    data : pandas DataFrame\n        DataFrame\n    correction : string or boolean\n        If True, return Greenhouse-Geisser corrected p-value.\n        If 'auto' (default), compute Mauchly's test of sphericity to determine\n        whether the p-values needs to be corrected.\n    remove_na : boolean\n        If True, automatically remove from the analysis subjects with one or\n        more missing values::\n\n            Ss    x1       x2       x3\n            1     5.0      4.2      nan\n            2     4.6      3.6      3.9\n\n        In this example, if remove_na == True, Ss 1 will be removed from the\n        ANOVA because of the x3 missing value. If False, the two non-missing\n        values will be included in the analysis.\n    export_filename : string\n        Filename (without extension) for the output file.\n        If None, do not export the table.\n        By default, the file will be created in the current python console\n        directory. To change that, specify the filename with full path.\n\n    Returns\n    -------\n    aov : DataFrame\n        ANOVA summary ::\n\n        'Source' : Names of the factor considered\n        'ddof1' : Degrees of freedom (numerator)\n        'ddof2' : Degrees of freedom (denominator)\n        'F' : F-values\n        'p-unc' : Uncorrected p-values\n        'np2' : Partial eta-square effect sizes\n        'p-GG-corr' : Greenhouse-Geisser corrected p-values\n        'W-Mauchly' : Mauchly statistic\n        'X2-Mauchly' : Chi-square statistic of the Mauchly test\n        'DF-Mauchly' : Degrees of freedom for the Mauchly test\n        'p-Mauchly' : p-value of the Mauchly test\n        'sphericity' : sphericity of the data (boolean)\n\n    See Also\n    --------\n    anova : One-way ANOVA\n    rm_anova : One-way repeated measures ANOVA\n\n    Examples\n    --------\n    Compute a two-way mixed model ANOVA.\n\n        >>> import pandas as pd\n        >>> from pingouin import mixed_anova, print_table\n        >>> df = pd.read_csv('dataset.csv')\n        >>> aov = mixed_anova(dv='DV', within='Time', between='Group', data=df,\n                             correction='auto', remove_na=False)\n        >>> print_table(aov)\n    \"\"\"\n    from scipy.stats import f\n    # Check data\n    _check_dataframe(dv=dv, within=within, between=between, data=data,\n                     effects='interaction')\n    # Remove NaN\n    if remove_na and data[dv].isnull().values.any():\n        data = _remove_rm_na(dv=dv, within=within, data=data)\n    # Reset index (avoid duplicate axis error)\n    data = data.reset_index(drop=True)\n\n    # SUMS OF SQUARES\n    grandmean = data[dv].mean()\n    # Extract main effects of time and between\n    mtime = rm_anova(dv=dv, within=within, data=data, correction=correction,\n                     remove_na=False, detailed=True)\n    mbetw = anova(dv=dv, between=between, data=data, detailed=True)\n    # Extract SS total, residuals and interactions\n    grp = data.groupby([between, within])[dv]\n    sstotal = grp.apply(lambda x: (x - grandmean)**2).sum()\n    # sst = residuals within + residuals between\n    sst = grp.apply(lambda x: (x - x.mean())**2).sum()\n    # Interaction\n    ssinter = sstotal - (sst + mtime.loc[0, 'SS'] + mbetw.loc[0, 'SS'])\n    sswg = mtime.loc[1, 'SS'] - ssinter\n    sseb = sstotal - (mtime.loc[0, 'SS'] + mbetw.loc[0, 'SS'] + sswg + ssinter)\n\n    # DEGREES OF FREEDOM\n    n_obs = data.groupby(within)[dv].count().max()\n    dftime = mtime.loc[0, 'DF']\n    dfbetween = mbetw.loc[0, 'DF']\n    dfeb = n_obs - data.groupby(between)[dv].count().count()\n    dfwg = dftime * dfeb\n    dfinter = mtime.loc[0, 'DF'] * mbetw.loc[0, 'DF']\n\n    # MEAN SQUARES\n    mseb = sseb / dfeb\n    mswg = sswg / dfwg\n    msinter = ssinter / dfinter\n\n    # F VALUES\n    fbetween = mbetw.loc[0, 'MS'] / mseb\n    ftime = mtime.loc[0, 'MS'] / mswg\n    finter = msinter / mswg\n\n    # P-values\n    pbetween = f(dfbetween, dfeb).sf(fbetween)\n    ptime = f(dftime, dfwg).sf(ftime)\n    pinter = f(dfinter, dfwg).sf(finter)\n\n    # Effects sizes\n    npsq_between = fbetween * dfbetween / (fbetween * dfbetween + dfeb)\n    npsq_time = ftime * dftime / (ftime * dftime + dfwg)\n    npsq_inter = ssinter / (ssinter + sswg)\n\n    # Stats table\n    aov = pd.concat([mbetw.drop(1), mtime.drop(1)], sort=False,\n                    ignore_index=True)\n    # Update values\n    aov.rename(columns={'DF': 'DF1'}, inplace=True)\n    aov.loc[0, 'F'], aov.loc[1, 'F'] = fbetween, ftime\n    aov.loc[0, 'p-unc'], aov.loc[1, 'p-unc'] = pbetween, ptime\n    aov.loc[0, 'np2'], aov.loc[1, 'np2'] = npsq_between, npsq_time\n    aov = aov.append({'Source': 'Interaction',\n                      'SS': ssinter,\n                      'DF1': dfinter,\n                      'MS': msinter,\n                      'F': finter,\n                      'p-unc': pinter,\n                      'np2': npsq_inter\n                      }, ignore_index=True)\n\n    aov['DF2'] = [dfeb, dfwg, dfwg]\n    col_order = ['Source', 'SS', 'DF1', 'DF2', 'MS', 'F', 'p-unc', 'np2',\n                 'p-GG-corr', 'sphericity', 'W-Mauchly', 'X2-Mauchly',\n                 'DF-Mauchly', 'p-Mauchly']\n\n    aov = aov.reindex(columns=col_order)\n    aov.dropna(how='all', axis=1, inplace=True)\n\n    # Export to .csv\n    if export_filename is not None:\n        _export_table(aov, export_filename)\n    return aov\n", "meta": {"hexsha": "cd4b123a0d6abf14d16636e63512a5cf8e68c18a", "size": 36103, "ext": "py", "lang": "Python", "max_stars_repo_path": "pingouinparametrics.py", "max_stars_repo_name": "bsheese/AtlesDescriptives", "max_stars_repo_head_hexsha": "febfde7d5bbe8abf686570db862f42738a4ad1fe", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pingouinparametrics.py", "max_issues_repo_name": "bsheese/AtlesDescriptives", "max_issues_repo_head_hexsha": "febfde7d5bbe8abf686570db862f42738a4ad1fe", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pingouinparametrics.py", "max_forks_repo_name": "bsheese/AtlesDescriptives", "max_forks_repo_head_hexsha": "febfde7d5bbe8abf686570db862f42738a4ad1fe", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.1220183486, "max_line_length": 79, "alphanum_fraction": 0.5670719885, "include": true, "reason": "import numpy,from numpy,from scipy", "num_tokens": 10224, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49609382947091957, "lm_q2_score": 0.10521053530027198, "lm_q1q2_score": 0.05219429735779729}}
{"text": "\"\"\"\nSea Ice Diagnostics.\n====================\n\nDiagnostic to produce a series of images which are useful for evaluating\nthe behaviour of the a sea ice model.\n\nThere are three kinds of plots shown here.\n1. Sea ice Extent maps plots with a stereoscoic projection.\n2. Maps plots of individual models ice fracrtion.\n3. Time series plots for the total ice extent.\n\nAll three kinds of plots are made for both Summer and Winter in both the\nNorth and Southern hemisphere.\n\nNote that this diagnostic assumes that the preprocessors do the bulk of the\nhard work, and that the cube received by this diagnostic (via the settings.yml\nand metadata.yml files) has no time component, a small number of depth layers,\nand a latitude and longitude coordinates.\n\nThis diagnostic takes data from either North or South hemisphere, and\nfrom either December-January-February or June-July-August. This diagnostic\nrequires the data to be 2D+time, and typically expects the data field to be\nthe sea ice cover.\nAn approproate preprocessor would be::\n\n  preprocessors:\n    timeseries_NHW_ice_extent: # North Hemisphere Winter ice_extent\n      custom_order: true\n      extract_time:\n          start_year: 1960\n          start_month: 12\n          start_day: 1\n          end_year: 2005\n          end_month: 9\n          end_day: 31\n      extract_season:\n        season: DJF\n      extract_region:\n        start_longitude: -180.\n        end_longitude: 180.\n        start_latitude: 0.\n        end_latitude: 90.\n\n\nNote that this recipe may not function on machines with no access to the\ninternet, as cartopy may try to download the shapefiles. The solution to\nthis issue is the put the relevant cartopy shapefiles on a disk visible to your\nmachine, then link that path to ESMValTool via the `auxiliary_data_dir`\nvariable. The cartopy masking files can be downloaded from::\n\n    https://www.naturalearthdata.com/downloads/\n\nHere, cartopy uses the 1:10, physical coastlines and land files::\n\n        110m_coastline.dbf  110m_coastline.shp  110m_coastline.shx\n        110m_land.dbf  110m_land.shp  110m_land.shx\n\nThis tool is part of the ocean diagnostic tools package in the ESMValTool.\n\nAuthor: Lee de Mora (PML)\n        ledm@pml.ac.uk\n\"\"\"\nimport logging\nimport os\nimport sys\nfrom itertools import product\n\nimport cartopy\nimport iris\nimport iris.coord_categorisation\nimport iris.quickplot as qplt\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nfrom esmvaltool.diag_scripts.ocean import diagnostic_tools as diagtools\nfrom esmvaltool.diag_scripts.shared import run_diagnostic\n\n# This part sends debug statements to stdout\nlogger = logging.getLogger(os.path.basename(__file__))\nlogging.getLogger().addHandler(logging.StreamHandler(sys.stdout))\n\n\n# Note that this recipe may not function on machines with no access to\n# the internet, as cartopy may try to download geographic files.\n\n\ndef create_ice_cmap(threshold=0.15):\n    \"\"\"\n    Create colour map with ocean blue below a threshold and white above.\n\n    Parameters\n    ----------\n    threshold: float\n        The threshold for the line between blue and white.\n\n    Returns\n    -------\n    matplotlib.colors.LinearSegmentedColormap:\n        The resulting colour map.\n\n    \"\"\"\n    threshold = threshold / 100.\n    ice_cmap_dict = {\n        'red': ((0., 0.0313, 0.0313), (threshold, 0.0313, 1.), (1., 1., 1.)),\n        'green': ((0., 0.237, 0.237), (threshold, 0.237, 1.), (1., 1., 1.)),\n        'blue': ((0., 0.456, 0.456), (threshold, 0.456, 1.), (1., 1., 1.))\n    }\n\n    return matplotlib.colors.LinearSegmentedColormap('ice_cmap', ice_cmap_dict)\n\n\ndef calculate_area_time_series(cube, plot_type, threshold):\n    \"\"\"\n    Calculate the area of unmasked cube cells.\n\n    Requires a cube with two spacial dimensions. (no depth coordinate).\n\n    Parameters\n    ----------\n    cube: iris.cube.Cube\n        Data Cube\n    plot_type: str\n        The type of plot: ice extent or ice area\n    threshold: float\n        The threshold for ice fraction (typically 15%)\n\n    Returns\n    -------\n    numpy array:\n        An numpy array containing the time points.\n    numpy.array:\n        An numpy array containing the total ice extent or total ice area.\n\n    \"\"\"\n    data = []\n    times = diagtools.cube_time_to_float(cube)\n    for time_itr, time in enumerate(times):\n        icedata = cube[time_itr].data\n\n        area = iris.analysis.cartography.area_weights(cube[time_itr])\n        if plot_type.lower() == 'ice extent':\n            # Ice extend is the area with more than 15% ice cover.\n            icedata = np.ma.masked_where(icedata < threshold, icedata)\n            total_area = np.ma.masked_where(icedata.mask, area.data).sum()\n        if plot_type.lower() == 'ice area':\n            # Ice area is cover * cell area\n            total_area = np.sum(icedata * area)\n\n        logger.debug('Calculating time series area: %s, %s, %s,', time_itr,\n                     time, total_area)\n        data.append(total_area)\n\n    ######\n    # Create a small dummy output array\n    data = np.array(data)\n    return times, data\n\n\ndef make_ts_plots(\n        cfg,\n        metadata,\n        filename,\n):\n    \"\"\"\n    Make a ice extent and ice area time series plot for an individual model.\n\n    Parameters\n    ----------\n    cfg: dict\n        the opened global config dictionairy, passed by ESMValTool.\n    metadata: dict\n        The metadata dictionairy for a specific model.\n    filename: str\n        The preprocessed model file.\n\n    \"\"\"\n    # Load cube and set up units\n    cube = iris.load_cube(filename)\n    iris.coord_categorisation.add_year(cube, 'time')\n    cube = diagtools.bgc_units(cube, metadata['short_name'])\n    cube = agregate_by_season(cube)\n\n    # Is this data is a multi-model dataset?\n    multi_model = metadata['dataset'].find('MultiModel') > -1\n\n    # Make a dict of cubes for each layer.\n    cubes = diagtools.make_cube_layer_dict(cube)\n\n    # Load image format extention\n    image_extention = diagtools.get_image_format(cfg)\n\n    # # Load threshold, pole, season.\n    threshold = float(cfg['threshold'])\n    pole = get_pole(cube)\n    season = get_season(cube)\n\n    # Making plots for each layer\n    for plot_type in ['Ice Extent', 'Ice Area']:\n        for layer_index, (layer, cube_layer) in enumerate(cubes.items()):\n            layer = str(layer)\n\n            times, data = calculate_area_time_series(cube_layer, plot_type,\n                                                     threshold)\n\n            plt.plot(times, data)\n\n            # Add title to plot\n            title = ' '.join(\n                [metadata['dataset'], pole, 'hemisphere', season, plot_type])\n            if layer:\n                title = ' '.join([\n                    title, '(', layer,\n                    str(cube_layer.coords('depth')[0].units), ')'\n                ])\n            plt.title(title)\n\n            # y axis label:\n            plt.ylabel(' '.join([plot_type, 'm^2']))\n\n            # Determine image filename:\n            suffix = '_'.join(['ts', metadata['preprocessor'], season, pole,\n                               plot_type, str(layer_index)])\\\n                     + image_extention\n            suffix = suffix.replace(' ', '')\n            if multi_model:\n                path = diagtools.folder(\n                    cfg['plot_dir']) + os.path.basename(filename)\n                path = path.replace('.nc', suffix)\n            else:\n                path = diagtools.get_image_path(\n                    cfg,\n                    metadata,\n                    suffix=suffix,\n                )\n\n            # Saving files:\n            if cfg['write_plots']:\n                logger.info('Saving plots to %s', path)\n                plt.savefig(path)\n\n            plt.close()\n\n\ndef make_polar_map(\n        cube,\n        pole='North',\n        cmap='Blues_r',\n):\n    \"\"\"\n    Make a polar stereoscopic map plot.\n\n    The cube is the opened cube (two dimensional),\n    pole is the polar region (North/South)\n    cmap is the colourmap,\n\n    Parameters\n    ----------\n    cube: iris.cube.Cube\n        Data Cube\n    pole: str\n        The hemisphere\n    cmap: str\n        The string describing the matplotlib colourmap.\n\n    Returns\n    ----------\n    matplotlib.pyplot.figure:\n        The matplotlib figure where the map was drawn.\n    matplotlib.pyplot.axes:\n        The matplotlib axes where the map was drawn.\n\n    \"\"\"\n    fig = plt.figure()\n    fig.set_size_inches(7, 7)\n\n    # ####\n    # Set  limits, based on https://nedbatchelder.com/blog/200806/pylint.html\n\n    if pole not in ['North', 'South']:\n        logger.fatal('make_polar_map: hemisphere not provided.')\n\n    if pole == 'North':  # North Hemisphere\n        ax1 = plt.subplot(111, projection=cartopy.crs.NorthPolarStereo())\n        ax1.set_extent([-180, 180, 50, 90], cartopy.crs.PlateCarree())\n\n    if pole == 'South':  # South Hemisphere\n        ax1 = plt.subplot(111, projection=cartopy.crs.SouthPolarStereo())\n        ax1.set_extent([-180, 180, -90, -50], cartopy.crs.PlateCarree())\n\n    linrange = np.linspace(0., 100., 21.)\n    qplt.contourf(cube, linrange, cmap=cmap, linewidth=0, rasterized=True)\n    plt.tight_layout()\n\n    try:\n        ax1.add_feature(\n            cartopy.feature.LAND,\n            zorder=10,\n            facecolor=[0.8, 0.8, 0.8],\n        )\n    except ConnectionRefusedError:\n        logger.error('Cartopy was unable add coastlines due to  a '\n                     'connection error.')\n    ax1.gridlines(\n        linewidth=0.5, color='black', zorder=20, alpha=0.5, linestyle='--')\n    try:\n        plt.gca().coastlines()\n    except AttributeError:\n        logger.warning('make_polar_map: Not able to add coastlines')\n    return fig\n\n\ndef get_pole(cube):\n    \"\"\"\n    Figure out the hemisphere and returns it as a string (North or South).\n\n    Parameters\n    ----------\n    cube: iris.cube.Cube\n        Data Cube\n\n    Returns\n    ----------\n    str:\n        The hemisphere (North or South)\n\n    \"\"\"\n    margin = 5.\n    if np.max(cube.coord('latitude').points) < 0. + margin:\n        return 'South'\n    if np.min(cube.coord('latitude').points) > 0. - margin:\n        return 'North'\n    logger.fatal('get_pole: Not able to determine hemisphere.')\n    return False\n\n\ndef get_time_string(cube):\n    \"\"\"\n    Return a climatological season string in the format: \"year season\".\n\n    Parameters\n    ----------\n    cube: iris.cube.Cube\n        Data Cube\n\n    Returns\n    ----------\n    str:\n        The climatological season as a string\n\n    \"\"\"\n    season = cube.coord('clim_season').points\n    year = cube.coord('year').points\n    return str(int(year[0])) + ' ' + season[0].upper()\n\n\ndef get_year(cube):\n    \"\"\"\n    Return the cube year as a string.\n\n    Parameters\n    ----------\n    cube: iris.cube.Cube\n        Data Cube\n\n    Returns\n    ----------\n    str:\n        The year as a string\n\n    \"\"\"\n    year = cube.coord('year').points\n    return str(int(year))\n\n\ndef get_season(cube):\n    \"\"\"\n    Return a climatological season time string.\n\n    Parameters\n    ----------\n    cube: iris.cube.Cube\n        Data Cube\n\n    Returns\n    ----------\n    str:\n        The climatological season as a string\n\n    \"\"\"\n    season = cube.coord('clim_season').points\n    return season[0].upper()\n\n\ndef make_map_plots(\n        cfg,\n        metadata,\n        filename,\n):\n    \"\"\"\n    Make a simple map plot for an individual model.\n\n    Parameters\n    ----------\n    cfg: dict\n        the opened global config dictionairy, passed by ESMValTool.\n    metadata: dict\n        The metadata dictionairy for a specific model.\n    filename: str\n        The preprocessed model file.\n\n    \"\"\"\n    # Load cube and set up units\n    cube = iris.load_cube(filename)\n    iris.coord_categorisation.add_year(cube, 'time')\n    cube = diagtools.bgc_units(cube, metadata['short_name'])\n    cube = agregate_by_season(cube)\n\n    # Is this data is a multi-model dataset?\n    multi_model = metadata['dataset'].find('MultiModel') > -1\n\n    # Make a dict of cubes for each layer.\n    cubes = diagtools.make_cube_layer_dict(cube)\n\n    # Load image format extention and threshold.\n    image_extention = diagtools.get_image_format(cfg)\n    threshold = float(cfg['threshold'])\n\n    # Making plots for each layer\n    plot_types = ['Fractional cover', 'Ice Extent']\n    plot_times = [0, -1]\n    for plot_type, plot_time in product(plot_types, plot_times):\n        for layer_index, (layer, cube_layer) in enumerate(cubes.items()):\n            layer = str(layer)\n\n            if plot_type == 'Fractional cover':\n                cmap = 'Blues_r'\n            if plot_type == 'Ice Extent':\n                cmap = create_ice_cmap(threshold)\n\n            cube = cube_layer[plot_time]\n\n            # use cube to determine which hemisphere, season and year.\n            pole = get_pole(cube)\n            time_str = get_time_string(cube)\n\n            # Make the polar map.\n            make_polar_map(cube, pole=pole, cmap=cmap)\n\n            # Add title to plot\n            title = ' '.join([metadata['dataset'], plot_type, time_str])\n            if layer:\n                title = ' '.join([\n                    title, '(', layer,\n                    str(cube_layer.coords('depth')[0].units), ')'\n                ])\n            plt.title(title)\n\n            # Determine image filename:\n            suffix = '_'.join(\n                ['ortho_map', plot_type, time_str,\n                 str(layer_index)])\n            suffix = suffix.replace(' ', '') + image_extention\n            if multi_model:\n                path = diagtools.folder(cfg['plot_dir'])\n                path = path + os.path.basename(filename)\n                path = path.replace('.nc', suffix)\n            else:\n                path = diagtools.get_image_path(\n                    cfg,\n                    metadata,\n                    suffix=suffix,\n                )\n\n            # Saving files:\n            if cfg['write_plots']:\n                logger.info('Saving plots to %s', path)\n                plt.savefig(path)\n\n            plt.close()\n\n\ndef agregate_by_season(cube):\n    \"\"\"\n    Aggregate the cube into seasonal means.\n\n    Note that it is not currently possible to do this in the preprocessor,\n    as the seasonal mean changes the cube units.\n\n    Parameters\n    ----------\n    cube: iris.cube.Cube\n        Data Cube\n\n    Returns\n    ----------\n    iris.cube.Cube:\n        Data Cube with the seasonal means\n\n    \"\"\"\n    if not cube.coords('clim_season'):\n        iris.coord_categorisation.add_season(cube, 'time', name='clim_season')\n    if not cube.coords('season_year'):\n        iris.coord_categorisation.add_season_year(\n            cube, 'time', name='season_year')\n    return cube.aggregated_by(['clim_season', 'season_year'],\n                              iris.analysis.MEAN)\n\n\ndef make_map_extent_plots(\n        cfg,\n        metadata,\n        filename,\n):\n    \"\"\"\n    Make an extent map plot showing several times for an individual model.\n\n    Parameters\n    ----------\n    cfg: dict\n        the opened global config dictionairy, passed by ESMValTool.\n    metadata: dict\n        The metadata dictionairy for a specific model.\n    filename: str\n        The preprocessed model file.\n\n    \"\"\"\n    # Load cube and set up units\n    cube = iris.load_cube(filename)\n    iris.coord_categorisation.add_year(cube, 'time')\n    cube = diagtools.bgc_units(cube, metadata['short_name'])\n    cube = agregate_by_season(cube)\n\n    # Is this data is a multi-model dataset?\n    multi_model = metadata['dataset'].find('MultiModel') > -1\n\n    # Make a dict of cubes for each layer.\n    cubes = diagtools.make_cube_layer_dict(cube)\n\n    # Load image format extention\n    image_extention = diagtools.get_image_format(cfg)\n\n    # Load threshold, pole and season\n    threshold = float(cfg['threshold'])\n    pole = get_pole(cube)\n    season = get_season(cube)\n\n    # Start making figure\n    for layer_index, (layer, cube_layer) in enumerate(cubes.items()):\n\n        fig = plt.figure()\n        fig.set_size_inches(7, 7)\n\n        if pole == 'North':  # North Hemisphere\n            projection = cartopy.crs.NorthPolarStereo()\n            ax1 = plt.subplot(111, projection=projection)\n            ax1.set_extent([-180, 180, 50, 90], cartopy.crs.PlateCarree())\n\n        if pole == 'South':  # South Hemisphere\n            projection = cartopy.crs.SouthPolarStereo()\n            ax1 = plt.subplot(111, projection=projection)\n            ax1.set_extent([-180, 180, -90, -50], cartopy.crs.PlateCarree())\n        try:\n            ax1.add_feature(\n                cartopy.feature.LAND, zorder=10, facecolor=[0.8, 0.8, 0.8])\n        except ConnectionRefusedError:\n            logger.error('Cartopy was unable add coastlines due to  a '\n                         'connection error.')\n\n        ax1.gridlines(\n            linewidth=0.5, color='black', zorder=20, alpha=0.5, linestyle='--')\n\n        try:\n            plt.gca().coastlines()\n        except AttributeError:\n            logger.warning('make_polar_map: Not able to add coastlines')\n\n        times = np.array(cube.coord('time').points.astype(float))\n        plot_desc = {}\n        for time_itr, time in enumerate(times):\n            cube = cube_layer[time_itr]\n            line_width = 1\n            color = plt.cm.jet(float(time_itr) / float(len(times)))\n            label = get_year(cube)\n            plot_desc[time] = {'label': label,\n                               'c': [color, ],\n                               'lw': [line_width, ],\n                               'ls': ['-', ]}\n\n            layer = str(layer)\n            qplt.contour(cube,\n                         [threshold, ],\n                         colors=plot_desc[time]['c'],\n                         linewidths=plot_desc[time]['lw'],\n                         linestyles=plot_desc[time]['ls'],\n                         rasterized=True)\n\n        # Add legend\n        legend_size = len(plot_desc) + 1\n        ncols = int(legend_size / 25) + 1\n        ax1.set_position([\n            ax1.get_position().x0,\n            ax1.get_position().y0,\n            ax1.get_position().width * (1. - 0.1 * ncols),\n            ax1.get_position().height\n        ])\n\n        fig.set_size_inches(7 + ncols * 1.2, 7)\n\n        # Construct dummy plots.\n        for i in sorted(plot_desc):\n            plt.plot(\n                [],\n                [],\n                c=plot_desc[i]['c'][0],\n                lw=plot_desc[i]['lw'][0],\n                ls=plot_desc[i]['ls'][0],\n                label=plot_desc[i]['label'],\n            )\n\n        legd = ax1.legend(\n            loc='center left',\n            ncol=ncols,\n            prop={'size': 10},\n            bbox_to_anchor=(1., 0.5))\n        legd.draw_frame(False)\n        legd.get_frame().set_alpha(0.)\n\n        # Add title to plot\n        title = ' '.join([\n            metadata['dataset'],\n        ])\n        if layer:\n            title = ' '.join([\n                title, '(', layer,\n                str(cube_layer.coords('depth')[0].units), ')'\n            ])\n        plt.title(title)\n\n        # Determine image filename:\n        suffix = '_'.join(['ortho_map', pole, season, str(layer_index)])\n        suffix = suffix.replace(' ', '') + image_extention\n        if multi_model:\n            path = diagtools.folder(cfg['plot_dir'])\n            path = path + os.path.basename(filename)\n            path = path.replace('.nc', suffix)\n        else:\n            path = diagtools.get_image_path(\n                cfg,\n                metadata,\n                suffix=suffix,\n            )\n\n        # Saving files:\n        if cfg['write_plots']:\n            logger.info('Saving plots to %s', path)\n            plt.savefig(path)\n        plt.close()\n\n\ndef main(cfg):\n    \"\"\"\n    Load the config file and metadata, then pass them the plot making tools.\n\n    Parameters\n    ----------\n    cfg: dict\n        the opened global config dictionairy, passed by ESMValTool.\n\n    \"\"\"\n    cartopy.config['data_dir'] = cfg['auxiliary_data_dir']\n\n    for index, metadata_filename in enumerate(cfg['input_files']):\n        logger.info(\n            'metadata filename:\\t%s',\n            metadata_filename,\n        )\n\n        metadatas = diagtools.get_input_files(cfg, index=index)\n        for filename in sorted(metadatas):\n\n            logger.info('-----------------')\n            logger.info(\n                'model filenames:\\t%s',\n                filename,\n            )\n            ######\n            # extent maps plots of individual models\n            make_map_extent_plots(cfg, metadatas[filename], filename)\n\n            ######\n            # maps plots of individual models\n            make_map_plots(cfg, metadatas[filename], filename)\n\n            ######\n            # time series plots o\n            make_ts_plots(cfg, metadatas[filename], filename)\n\n    logger.info('Success')\n\n\nif __name__ == '__main__':\n    with run_diagnostic() as config:\n        main(config)\n", "meta": {"hexsha": "b9f9109313908cd8eb7bbda571041dbc120af3a2", "size": 20795, "ext": "py", "lang": "Python", "max_stars_repo_path": "esmvaltool/diag_scripts/ocean/diagnostic_seaice.py", "max_stars_repo_name": "chrisdane/ESMValTool", "max_stars_repo_head_hexsha": "35e0c2b0dbaa0927a2d677f382b43520633a1a0f", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-20T13:59:07.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-20T13:59:07.000Z", "max_issues_repo_path": "esmvaltool/diag_scripts/ocean/diagnostic_seaice.py", "max_issues_repo_name": "chrisdane/ESMValTool", "max_issues_repo_head_hexsha": "35e0c2b0dbaa0927a2d677f382b43520633a1a0f", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "esmvaltool/diag_scripts/ocean/diagnostic_seaice.py", "max_forks_repo_name": "chrisdane/ESMValTool", "max_forks_repo_head_hexsha": "35e0c2b0dbaa0927a2d677f382b43520633a1a0f", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-20T13:59:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-20T13:59:21.000Z", "avg_line_length": 29.454674221, "max_line_length": 79, "alphanum_fraction": 0.5813416687, "include": true, "reason": "import numpy", "num_tokens": 4788, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44167299096624174, "lm_q2_score": 0.11757212272365286, "lm_q1q2_score": 0.051928431097605796}}
{"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\n\n@author: Frank Nussbaum (frank.nussbaum@uni-jena.de), 2019\n\n\"\"\"\nimport abc\nimport numpy as np\n\n#import time\n\n# pylint: disable=R0914\n\n\nclass BaseAdmm(abc.ABC):\n    \"\"\"A base class for ADMM solvers.\n    \n    Attributes:\n        admm_param (float): initial admm parameter\n        opts (dict): dictionary of solver options\n    \"\"\"\n\n    def __init__(self):\n        super().__init__()\n        self.admm_param = 1  # TODO(franknu): external access\n        self.opts = {}\n        self.set_defaults_admm()\n\n    @abc.abstractmethod\n    def _do_iter_admm(self, current_vars: tuple):\n        \"\"\"perform computations of one ADMM iteration\"\"\"\n        raise NotImplementedError  # override in derived classes\n\n    @abc.abstractmethod\n    def _initialize_admm(self):\n        \"\"\"initialize ADMM variables\"\"\"\n        raise NotImplementedError  # override in derived classes\n\n#    def _collect(self, current_vars: tuple):\n#        \"\"\"store information of ADMM variables in dictionairy\"\"\"\n#        raise NotImplementedError  # override in derived classes\n\n    def _report(self, out):\n        \"\"\"print stats after solving\"\"\"\n        print('>', out['message'])\n        print('> (P)ADMM: obj: %e, iter: %d, resid:%e' %\n              (out['obj'], out['iter'], out['resid']))\n        try:\n            print('> regparams used:', self.get_regparams())\n        except AttributeError:\n            # Method get_regparams does not exist\n            pass\n\n        for i, var in enumerate(out['solution']):\n            print('norm optvar%d=%f' % (i, np.linalg.norm(var)))\n\n    def set_defaults_admm(self):\n        \"\"\"Set default solver options in class attribute opt.\n        \n        Adjustable solver options contain abstol, reltol,\n        maxiter, stoptol, verb, etc.\"\"\"\n        self.opts = {}\n        self.opts.setdefault('abstol', 1e-5)\n        self.opts.setdefault('reltol', 1e-5)\n\n        self.opts.setdefault('continuation', 1)\n        self.opts.setdefault('num_continuation', 10)\n        #        self.opts.setdefault('cont_adaptive', 10)\n        self.opts.setdefault('continuation_fac', 2)\n        #        self.opts.setdefault('eta', .25)\n        #        self.opts.setdefault('muf', 1e-6)\n        self.opts.setdefault('maxiter', 500)\n        self.opts.setdefault('stoptol', 1e-5)\n\n        self.opts.setdefault('verb', 0)\n\n    def _solve(self, warminit=None):\n        \"\"\"\n        solve a generic ADMM problem\n        \"\"\"\n        ## initialization\n        current_vars = self._initialize_admm()\n        if not warminit is None:\n            current_vars = warminit\n\n        hist = np.empty((5, self.opts['maxiter'] + 1))\n        history = {\n            'objval': hist[0, :],\n            'r_norm': hist[1, :],\n            's_norm': hist[2, :],\n            'eps_pri': hist[3, :],\n            'eps_dual': hist[4, :]\n        }\n\n        for i in range(1, self.opts['maxiter'] + 1):\n            ## update Theta\n            current_vars, residuals, stats = self._do_iter_admm(current_vars)\n\n            ## diagnostics, reporting, termination checks\n            rnorm, snorm, eps_pri, eps_dual = residuals\n\n            history['objval'][i] = stats['admm_obj']\n\n            history['r_norm'][i] = rnorm\n            history['s_norm'][i] = snorm\n\n            history['eps_pri'][i] = eps_pri\n            history['eps_dual'][i] = eps_dual\n\n#            print(i % self.opts['verb'])\n            if self.opts['verb'] and i % self.opts['verb'] == 0:\n                print('%3d\\t%10.4f %10.4f %10.4f %10.4f %10.2f' %\n                      (i, history['r_norm'][i], history['eps_pri'][i],\n                       history['s_norm'][i], history['eps_dual'][i],\n                       history['objval'][i]))  # resid %10.2f\n\n            ## check stop\n            pridualresids_below_tolerance = (rnorm < eps_pri and\n                                             snorm < eps_dual)\n\n            if pridualresids_below_tolerance:\n                break\n\n            if self.opts['continuation'] and \\\n                i % self.opts['num_continuation'] == 0:\n                # self-adaptive update\n                # generally: larger admm_param leads to lower penalty on\n                # primal residual (resid)\n                admm_param_old = self.admm_param\n\n                admm_state = eps_pri, eps_dual, rnorm, snorm\n\n                if (i / self.opts['num_continuation']) % 5 == 1:\n                    self._cont_update_2019(admm_state)\n                else:\n                    self._cont_update_s2a(admm_state)\n\n                if self.opts['verb'] and self.admm_param != admm_param_old:\n                    print('>> New ADMM parameter', self.admm_param,\n                          '(old was %f)' % (admm_param_old))\n\n        out = {}\n        if pridualresids_below_tolerance:\n            out['message'] = b'CONVERGENCE: primal and dual residual below tolerance'\n        else:\n            out['message'] = b'STOP: TOTAL NO. of ITERATIONS EXCEEDS LIMIT'\n\n        out['history'] = history\n        out['iter'] = i\n        # out['admm_obj'] = history['objval'][i] # already in stats, see below\n\n        out.update(stats)\n\n        return out\n\n    def _cont_update_s2a(self, admm_state, criticalratio: int = 5):\n        \"\"\" update S2a from my master thesis\n        uses more robust constant size updates of admm_param\"\"\"\n\n        eps_pri, eps_dual, rnorm, snorm = admm_state\n\n        snorm_rel = snorm / eps_dual\n        rnorm_rel = rnorm / eps_pri\n        if snorm_rel < 1 and rnorm_rel < 1:\n            return  # residuals are already smaller than tolerancies\n\n#        print(snorm_rel, rnorm_rel)\n\n        ## do scaling of admm_param if necessary\n        if rnorm_rel > snorm_rel * criticalratio:\n            # decrease admm_param\n            self.admm_param /= self.opts['continuation_fac']\n        elif snorm_rel > rnorm_rel * criticalratio:\n            # increase admm_param\n            self.admm_param *= self.opts['continuation_fac']\n\n    def _cont_update_2019(self,\n                         admm_state,\n                         criticalratio: int = 5,\n                         cutoff: tuple = (1e-2, 1e2)):\n        \"\"\" update that respects current ratio of residuals with tolerancies\"\"\"\n        # TODO(franknu): consider speed of improvement instead of\n        # just current state? - hist as class variable??\n        # ML to learn update?\n        eps_pri, eps_dual, rnorm, snorm = admm_state\n        snorm_rel = snorm / eps_dual\n        rnorm_rel = rnorm / eps_pri\n\n        if snorm_rel < 1 and rnorm_rel < 1:\n            return  # residuals are already smaller than tolerancies\n\n        # do cutoff\n        lower, upper = cutoff\n        snorm_rel = min(upper, max((snorm_rel, lower)))\n        rnorm_rel = min(upper, max((rnorm_rel, lower)))\n\n        if snorm_rel < 1:\n            # decrease ADMM param\n            # increases penalty for violations of primal feasibiity\n            scaling_factor = 1 / rnorm_rel\n        elif rnorm_rel < 1:\n            # increase ADMM param\n            # decreases penalty for violations of primal feasibiity\n            scaling_factor = snorm_rel\n        else:\n            scaling_factor = snorm_rel / rnorm_rel\n\n#        if self.opts['verb']:\n#            print(snorm_rel, rnorm_rel)\n\n        ## do scaling of admm_param if necessary\n        if max((scaling_factor, 1 / scaling_factor)) > criticalratio:\n\n            if rnorm_rel >= 1 and snorm_rel >= 1:\n                scaling_factor = (scaling_factor)**.8\n                # inhibition, draw towards 1\n\n            if self.opts['verb']:\n                print('scaling_factor', scaling_factor)\n            self.admm_param *= scaling_factor\n\n    def solve(self, report=False, warminit=None, **kwargs):\n        \"\"\"solve the problem\n        \n        Args:\n            report (bool): whether to print additional summary.\n            warminit (solver state): starting point for the solver.\n            kwargs (optional): additional solver options to replace defaults. \n        \n        Returns:\n            dict: dictionary with info about solution/solving process\n        \"\"\"\n\n        self.opts.update(**kwargs) # update solver options\n\n        if report:\n            print('>solver options', self.opts)\n\n        ## select appropriate sparsity-inducing norms and corresponding proximity operators\n\n        out = self._solve(warminit=warminit)\n\n        if report:\n            self._report(out)\n\n        if not out['message'].startswith(b'CONV'):\n            print(out['message'])\n\n        return out\n", "meta": {"hexsha": "13433d234155bfb87361940b2ca4ce8a662aa4ad", "size": 8498, "ext": "py", "lang": "Python", "max_stars_repo_path": "cgmodsel/base_admm.py", "max_stars_repo_name": "franknu/cgmodsel", "max_stars_repo_head_hexsha": "b008ed88e4f10205ee0ff5e9433d5426c1d5ff6a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-09-01T08:39:14.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-01T08:39:14.000Z", "max_issues_repo_path": "cgmodsel/base_admm.py", "max_issues_repo_name": "franknu/cgmodsel", "max_issues_repo_head_hexsha": "b008ed88e4f10205ee0ff5e9433d5426c1d5ff6a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cgmodsel/base_admm.py", "max_forks_repo_name": "franknu/cgmodsel", "max_forks_repo_head_hexsha": "b008ed88e4f10205ee0ff5e9433d5426c1d5ff6a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-04T13:35:41.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-04T13:35:41.000Z", "avg_line_length": 33.8565737052, "max_line_length": 91, "alphanum_fraction": 0.5640150624, "include": true, "reason": "import numpy", "num_tokens": 2025, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.1037486365654557, "lm_q1q2_score": 0.05187431828272785}}
{"text": "# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sun May 10 09:59:15 2020\n\n@author: prophet lin\n\"\"\"\n\nimport os\nimport pandas as pd\nimport numpy as np\nout = open(\"./res.txt\", 'w+')\n\n#%% 读取生成式  @表示为空\ngenerator = {}\nstart = None    #开始符号\nter_set = set() #终结符集合\nnon_set = set() #非终结符集合\nall_set = set()\n#grammar2\nf = open('./tiny.txt')\nfor line in f:\n    line = line.split('->')\n    #添加开始符号\n    if not non_set:\n        start = line[0].split()[0]\n    #非终结符\n    non_sym = line[0].split()[0]\n    non_set.add(non_sym)\n    #右侧所有符号 \n    all_syms = line[1].split() #[:-1] delete '/n'\n    all_set = all_set.union(set(all_syms))\n    \n    if non_sym not in generator:\n        generator[non_sym] = []\n    generator[non_sym].append(all_syms)\n#求非终结符集\nter_set = all_set - non_set\nprint(\"起始符号：{0}\\n非终结符：{1}\\n终结符：{2}\\n===========\".format(start, non_set, ter_set), file=out)\n#%% 消除左递归\n\n#%% 提取左因子\n\n#%% 生成First集\nfirst = {}\n#第一轮 把所有开头的非终结符和空放入First集\nfor l_sym in generator:\n    for each in generator[l_sym]:\n        if l_sym not in first:\n            first[l_sym] = set()\n        if each[0] in ter_set:\n            first[l_sym].add(each[0])\n#循环轮 添加非终结符，循环直到不再变化\nupdate = 1\nwhile update == 1:\n    update = 0\n    for l_sym in generator:\n        for each in generator[l_sym]:\n            #处理空符号，尤其是前面所有的均为空\n            emputy_flag = 0\n            for i in range(len(each)):\n                if each[i] in non_set:\n                    #如果添加导致改变，设置标志位\n                    temp = first[l_sym].union( first[each[i]] - set('@') )\n                    if first[l_sym] != temp:\n                        update = 1\n                        first[l_sym] = temp\n                if each[i] in ter_set and each[i] not in first[l_sym]:\n                    update = 1\n                    first[l_sym].add(each[i])\n                if each[i] in ter_set or (each[i] in non_set and '@' not in first[each[i]]):\n                    emputy_flag = 1\n                    break\n                \n            if emputy_flag == 0:\n                first[l_sym].add('@')\n\nprint(\"First集：\", file=out)     \nfor item in first:\n    print(\"{0}:{1}\".format(item,first[item]), file=out)   \nprint(\"===========\", file=out)   \n#%% 生成Follow集\n# $ 加入起始符号\nfollow = {}        \nfor non_sym in non_set:\n    follow[non_sym] = set()\nfollow[start] = set('$')\n\n# 第一轮 将非终结符后的终结符添加到FOLLOW中\nfor l_sym in generator:\n    for each in generator[l_sym]:\n        for i in range(len(each)-1):\n            if each[i] in non_set and each[i+1] in ter_set:\n                follow[each[i]].add(each[i+1])\n#第二轮 集合间的同步，非终结符后的非终结符first集，左侧添加到右侧最后，循环直到不再变化\nupdate = 1\nwhile update == 1:\n    update = 0\n    for l_sym in generator:\n        for each in generator[l_sym]:\n            # 产生式后加入$,用来合并逻辑,不必从末尾向前找空，而是顺序向后\n            temp_produce = each.copy()\n            temp_produce.append('$')\n            for i in range(len(each)):\n                next_p = i\n                while True:\n                    next_p += 1\n                    #非终结符后的非终结符first集\n                    if temp_produce[i] in non_set and temp_produce[next_p] in non_set:\n                        temp = follow[temp_produce[i]].union( first[temp_produce[next_p]] - set('@') )\n                        if follow[temp_produce[i]] != temp:\n                            update = 1\n                            follow[temp_produce[i]] = temp\n                    #左侧follow添加到右侧最后\n                    if temp_produce[i] in non_set and temp_produce[next_p] == '$':\n                        temp = follow[temp_produce[i]].union( follow[l_sym] )\n                        if follow[temp_produce[i]] != temp:\n                            update = 1\n                            follow[temp_produce[i]] = temp\n                    if temp_produce[next_p] in ter_set or temp_produce[next_p] == '$' or ( '@' not in first[temp_produce[next_p]]):\n                        break\nprint(\"Follow集：\", file=out)     \nfor item in follow:\n    print(\"{0}:{1}\".format(item,follow[item]), file=out)   \nprint(\"===========\", file=out)       \n#%% 生成LL1分析表 判断是否是LL1文法\nvaild = True\nter_list = list(ter_set)\nnon_list = list(non_set)\nter_list.append('$')\nter_list.remove('@')\nll1_table = pd.DataFrame(columns = ter_list,index = non_list)\ngenerator_list = []\ncount = 0\nfor l_sym in generator:\n    for each in generator[l_sym]:\n        #print(each,count)\n        generator_list.append([l_sym,each])\n        if each[0] == '@':\n            #添加Follow\n            for sym in follow[l_sym]:\n                if np.isnan(ll1_table.loc[l_sym,sym]):\n                    ll1_table.loc[l_sym,sym] = count\n                else:\n                    vaild = False\n            count += 1\n            continue\n        if each[0] in ter_set:\n            if np.isnan(ll1_table.loc[l_sym,each[0]]):\n                ll1_table.loc[l_sym,each[0]] = count\n            else:\n                vaild = False\n        #TODO:处理first中有空的情况\n        if each[0] in non_set:\n            for sym in first[each[0]]:\n                if np.isnan(ll1_table.loc[l_sym,sym]):\n                    ll1_table.loc[l_sym,sym] = count\n                else:\n                    vaild = False\n        count += 1\n        \nif not vaild:\n    print('文法不满足LL（1）条件！')\nll1_table.to_excel('LL1.xlsx')\n#%% 分析栈分析代码 以及构造抽象语法树\ntoken_file = open('./token_list.txt')\ntokens = []\nfor line in token_file:\n    tokens.append(line[:-1])\ntokens.append('$')\nstack = []\nstack.append(\"$\")\nstack.append(start)\nwhile stack:\n    print('=====================\\n','stack:',stack,'\\n tokens:',tokens, file=out)\n    \n    #match\n    if stack[-1] in ter_set or (stack[-1] == '$' and tokens[-1] == '$'):\n        if stack[-1] == tokens[0]:\n            stack.pop()\n            tokens.pop(0)\n            continue\n        else:\n            print('不满足文法')\n            break\n    #action\n    if stack[-1] in non_set:\n        if np.isnan(ll1_table.loc[stack[-1],tokens[0]]):\n            print('不满足文法')\n            break\n        else:\n            use_p = generator_list[ll1_table.loc[stack[-1],tokens[0]]]\n            stack.pop()\n            temp = use_p[1].copy()\n            if temp[0] != '@':\n                temp.reverse()\n                stack.extend(temp)\n\n#%%\nout.close()\n'''\nupdate = 1\nwhile update == 1:\n    update = 0\n    for l_sym in generator:\n        #TODO:处理空符号，尤其是前面所有的均为空\n        for each in generator[l_sym]:\n            if each[0] in non_set:\n                #如果添加导致改变，设置标志位\n                temp = first[l_sym].union( first[each[0]] - set('@') )\n                if first[l_sym] != temp:\n                    update = 1\n                    first[l_sym] = temp\n'''", "meta": {"hexsha": "91571475e9a56d2372185bd8919a45ccd68e3c62", "size": 6497, "ext": "py", "lang": "Python", "max_stars_repo_path": "parser_backup.py", "max_stars_repo_name": "linprophet/LL1-parser", "max_stars_repo_head_hexsha": "fd48a4dea638b0ad92163db2ffbc42bc4869f37a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "parser_backup.py", "max_issues_repo_name": "linprophet/LL1-parser", "max_issues_repo_head_hexsha": "fd48a4dea638b0ad92163db2ffbc42bc4869f37a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "parser_backup.py", "max_forks_repo_name": "linprophet/LL1-parser", "max_forks_repo_head_hexsha": "fd48a4dea638b0ad92163db2ffbc42bc4869f37a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.5023474178, "max_line_length": 131, "alphanum_fraction": 0.5096198245, "include": true, "reason": "import numpy", "num_tokens": 1936, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657966593214324, "lm_q2_score": 0.10818896031297127, "lm_q1q2_score": 0.051560658563501754}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# Importing the required libraries\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport streamlit as st\nimport streamlit.components.v1 as components\nfrom PIL import Image\nimport plotly.express as px\nfrom streamlit_timeline import timeline\nimport plotly.graph_objects as go\nimport seaborn as sns\nimport plotly.figure_factory as ff\n\n###########################\n\nst.set_page_config(layout=\"wide\")\n\nst.title('How various factors have influenced the housing prices over the past 2 decades - A case Study 📔')\n\nst.sidebar.markdown('''\n# Contents\n- [Introduction](#introduction)\n- [Brief Timeline](#a-brief-timeline-of-major-economic-events)\n- [The Past 2 Decades](#factors-and-how-they-influenced-the-past-2-decades)\n    - [Demand](#demand)\n        - [Population](#population)\n        - [Unemployment](#unemployment)\n        - [Income](#income)\n        - [Mortgage Rate](#mortgage-rate)\n        - [Debt](#household-debt)\n    - [Supply](#supply)\n        - [Permits](#new-single-family-unit-permits)\n        - [Existing home sales](#existing-home-sales)\n        - [Foreclosures](#foreclosures)\n- [Most Influencial Factor](#determining-the-most-influencial-factor)\n    - [Correlation Analysis](#correlation-analysis)\n    - [Explanatory Regression Analysis](#explanatory-regression-analysis)\n- [Conclusion](#conclusion)\n- [Biblography](#biblography)\n        \n\n''', unsafe_allow_html=True)\n\n###########################    \n\nst.header('Introduction')\ncol1,col2 = st.columns((2,1))\ncol1.write('''\n\nSaying that the housing market is influenced by a myriad of factors could be an understatement. \nThe entire process of reverse engineering something as complex and as complicated as a housing market requires in-depth and \nunbiased analysis which in turn produces credible predictive analytics.\n\nThe **S&P CoreLogic Case-Shiller U.S. National Home Price NSA Index** measures the change in the value of the U.S. \nresidential housing market by tracking the purchase prices of single-family homes, which I have used as a proxy for home prices.\n\nAs of October 2021, there were 208.4 million single-family dwelling units in the United States and only 37.8 million multifamily units. \n**The size of single-family housing units has steadily risen since the start of the 21st century.**\n\nThere is an upward trend in the average size of floor area in new single-family homes. In 1975, a new home had an average floor area of about 1,660 square feet.\nBy 2019, this figure had **increased by** about 900 square feet.\n\n''')\n\nlabels = ['Multi-family dwelling unit', 'Single Family dewlling unit', 'Others']\nsizes = [37.75, 208.36, 10.67]\nexplode = (0, 0.1, 0)  # only \"explode\" the 2nd slice \n\nfig1, ax1 = plt.subplots()\nax1.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%',\n        shadow=True, startangle=90)\nax1.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.\nax1.set_title(\"The single-family units as a fraction of all the housing units in USA\", pad = 20)\n\ncol2.pyplot(fig1)\n\nst.write('''\nThe interavtive rgraph below shows how the S&P CoreLogic Case-Shiller U.S. National Home Price NSA Index has changed in the past 2 years. \nThe data has been adjusted to show quaterly mean.\n''')\n\ncol1,col2 = st.columns((2,1))\n\ndf = pd.read_csv('./data/cleaned/snp.csv')\ndf.rename(columns = {'CSUSHPISA':'Index'}, inplace = True)\nfig = px.line(df, x='DATE', y='Index')\nfig.update_xaxes(\n    rangeslider_visible=True,\n    rangeselector=dict(\n        buttons=list([\n            dict(count=6, label=\"6m\", step=\"month\", stepmode=\"backward\"),\n            dict(count=1, label=\"YTD\", step=\"year\", stepmode=\"todate\"),\n            dict(count=1, label=\"1y\", step=\"year\", stepmode=\"backward\"),\n            dict(step=\"all\")\n        ])\n    )\n)\ncol1.plotly_chart(fig)\n\ncol2.markdown('''_\n\\n \nThe Case Shiller Home Price Index averaged 169.87 points from 2000 until 2021. \n\\n It reached an all-time high of 257.10 points in April 2021.\n\\nIt reached a record low of 100 points in January 2000.\n''')\n\n###########################\nst.header('A Brief Timeline ⏱️ of Major Economic Events')\nwith open('data.json', \"r\") as f:\n    data = f.read()\n\n# render timeline\ntimeline(data, height=800)\n\n#####################\nst.header('Factors and How They Influenced The Past 2 Decades 📊')\nst.header('Population 🧑🏻‍🤝‍🧑🏾')\ncolm1,colm2 = st.columns((3,4))\ncolm1.write('''\nThe U.S. population increased by 10 percent between 2000 and 2010 and is projected to increase by 8 percent between 2010 and 2020, from 309 million to 333 million. An 8 percent gain would be the smallest percentage increase in the U.S. population between censuses since the 1930s.\n\\nThe population-housing relationship is a two-way street. On the one hand, population growth causes a shift in housing demand. Population growth, and especially an increase in the number of households, leads to an increase in housing demand.\n\\nPopulation decline might lead to a decrease in housing demand. This will, however, only happen in the long run, after not only the number of people but also the number of households has started to decline. The danger of population decline is greatest in remote rural areas and in areas with lower-quality housing.\nAt the same time, the supply of housing influences the opportunities for population increase through migration.\n\n''')\n\n\n\ndf = pd.read_csv('./data/cleaned/population_q_cleaned.csv')\ndf.rename(columns = {'POPTHM':'Population'}, inplace = True)\nfig = px.line(df, x='DATE', y=df.columns)\nfig.update_xaxes(\n    rangeslider_visible=True,\n    rangeselector=dict(\n        buttons=list([\n            dict(count=6, label=\"6m\", step=\"month\", stepmode=\"backward\"),\n            dict(count=1, label=\"YTD\", step=\"year\", stepmode=\"todate\"),\n            dict(count=1, label=\"1y\", step=\"year\", stepmode=\"backward\"),\n            dict(step=\"all\")\n        ])\n    )\n)\ncolm2.plotly_chart(fig)\n\ncol1,col2 = st.columns((3,4))\ndf = pd.read_csv('./data/cleaned/pops.csv')\ndf.rename(columns = {'CNP16OV_TTLHH':'No. of members in a household'}, inplace = True)\nfig = px.line(df, x='Date', y=df.columns)\nfig.update_xaxes(\n    rangeslider_visible=True,\n    rangeselector=dict(\n        buttons=list([\n            dict(count=6, label=\"6m\", step=\"month\", stepmode=\"backward\"),\n            dict(count=1, label=\"YTD\", step=\"year\", stepmode=\"todate\"),\n            dict(count=1, label=\"1y\", step=\"year\", stepmode=\"backward\"),\n            dict(step=\"all\")\n        ])\n    )\n)\nwith col2:\n    st.plotly_chart(fig)\n\nwith col1:\n    st.write('**Poplulation level/Total household** 🧑🏻‍🤝‍🧑🏾/🏠')\n    st.write('''\n    The graph shows that the number of people in each household has decreased in the longer time period. So the number of households in the US has increased faster than population, which means that any measure divided by population grows faster than one divided by number of households.\n    ''')\n\n\n#####################\nst.header('Unemployment')\ncolm1,colm2 = st.columns((3,4))\ndf = pd.read_csv('./data/cleaned/unemp.csv')\ndf.rename(columns = {'UNRATE':'Unemployment Rate in %'}, inplace = True)\nfig = px.line(df, x='DATE', y=df.columns)\nfig.update_xaxes(\n    rangeslider_visible=True,\n    rangeselector=dict(\n        buttons=list([\n            dict(count=6, label=\"6m\", step=\"month\", stepmode=\"backward\"),\n            dict(count=1, label=\"YTD\", step=\"year\", stepmode=\"todate\"),\n            dict(count=1, label=\"1y\", step=\"year\", stepmode=\"backward\"),\n            dict(step=\"all\")\n        ])\n    )\n)\ncolm2.plotly_chart(fig)\n\nwith colm1:\n    components.iframe(\"https://d3fy651gv2fhd3.cloudfront.net/embed/?s=usurtot&v=202203041337V20200908&d1=19970314&type=type=line&title=false&url2=/united-states/case-shiller-home-price-index&h=300&w=600\",width=600, height=300, scrolling=False)\n    st.write(\"Unemployment tracks the business cycle. Recessions are part of that cycle and can cause high unemployment. Businesses often lay off workers and, without an income, those jobless workers have less money to spend.\")\n\n\nst.write('''\nLower consumer spending reduces business revenue, which forces companies to cut more payroll. This downward cycle can be devastating to individuals and the economy.\nWhen unemployment is rising, fewer people will be able to afford a house. But, even the fear of unemployment may discourage people from entering the property market.\nAn increase in jobs, employees and wages consequently results in an increase in income for all workers in a country. With that, an increase in income also increases the demand for affordable housing.\n\\nDuring the Great Recession, unemployment reached 10% in October 2009. \nIn 2020, it reached double digits again at 14.7% in April when the U.S. was dealing with a pandemic and recession.\nThe US unemployment rate edged down to 3.8 percent in February of 2022 from 4 percent in the previous month, a new pandemic low and below market expectations of 3.9 percent. The number of unemployed persons edged down by 243 thousand to 6.270 million.\n\n''')\n############################\nst.header('Income 💵')\ncolm1,colm2 = st.columns((3,4))\ncolm1.write('''\nThe shortfall in household income is attributable in part to two recessions since 2000. The first recession, lasting from March 2001 to November 2001, was relatively short-lived.7 Yet household incomes were slow to recover from the 2001 recession and it was not until 2007 that the median income was restored to about its level in 2000.\n\n\\nBut 2007 also marked the onset of the Great Recession, and that delivered another blow to household incomes. This time it took until 2015 for incomes to approach their pre-recession level. Indeed, the median household income in 2015 – $70,200 – was no higher than its level in 2000, marking a 15-year period of stagnation, an episode of unprecedented duration in the past five decades.8\n\n\\nMore recent trends in household income suggest that the effects of the Great Recession may finally be in the past. From 2015 to 2018, the median U.S. household income increased from 70,200 to 74,600 dollars, at an annual average rate of 2.1%.\n''')\n\ncol1,col2 = st.columns((3,4))\nwith col2:\n    img = Image.open(\"aff.png\")\n    st.image(img)\n\nwith col1:\n    st.write('**Affordability of Homes**')\n    st.write('''\n    \nSteady job growth and an increase in the median wage continue to fuel housing demand. Aside from rising wages, another good sign of financial health is spending less disposable income on repaying debts like credit cards, auto loans, and personal loans.\n\nToday, household budgets continue to be the strongest they’ve been in over 40 years and a far cry from 2008, suggesting consumers have more disposable income to buy a home.\n\n    ''')\n\n\ndf = pd.read_csv('./data/cleaned/incomenew.csv')\ndf.rename(columns = {'MEHOINUSA672N':'Median Income'}, inplace = True)\ndf.rename(columns = {'HOUSTCB1FQ_HOUSTOB1FQ':'New Privately Owned Homes'}, inplace = True)\nfig = px.line(df, x='DATE', y=df.columns)\nfig.update_xaxes(\n    rangeslider_visible=True,\n    rangeselector=dict(\n        buttons=list([\n            dict(count=6, label=\"6m\", step=\"month\", stepmode=\"backward\"),\n            dict(count=1, label=\"YTD\", step=\"year\", stepmode=\"todate\"),\n            dict(count=1, label=\"1y\", step=\"year\", stepmode=\"backward\"),\n            dict(step=\"all\")\n        ])\n    )\n)\ncolm2.plotly_chart(fig)\n###########################\n\nst.header('Mortgage Rate')\ncolm1,colm2 = st.columns((3,4))\ncolm1.write('''\nMonetary policy affects interest rates, which affect mortgages, which affect housing market decisions. That may be simple to grasp, but the housing statistics may not follow such clear-cut patterns. \n\n\\nThe graph's red line represents the average 30-year fixed-rate mortgage for the last 20 years. For the same time period, the blue line in the graph represents the ratio of house starts built by contractors to housing starts built by owners. \n\n\\nFrom 2000 to 2007, this ratio remained largely steady, hovering around 1.5, meaning that contractors built roughly 60% of new starts. However, during periods of macroeconomic turmoil, the ratio has deviated from its historical average.\n\\nBut during the Great Recession, this ratio increased sharply, to over 2.0, peaking at 2.6 in 2016, which implies contractors built 72% of housing starts. In both cases, GDP declined and unemployment rose, but this housing measure behaved differently.\n''')\n\nst.write('''\nA clear difference between these two episodes is the level of mortgage rates: Rates were much higher in the Great Recession. As mortgage rates go up, the ratio goes down and vice versa.\nA potential reason is that, as the price of mortgages increases, the cost of purchasing a new home from a contractor increases relative to the cost of building one’s own home. And, if the costs are basically the same, \nmany would-be homeowners might choose to build their own home rather than purchase one that someone else built. \n''')\n\ndf = pd.read_csv('./data/cleaned/dd.csv')\ndf.rename(columns = {'MORTGAGE30US':'Mortgage Rate'}, inplace = True)\ndf.rename(columns = {'HOUSTCB1FQ_HOUSTOB1FQ':'New Privately Owned Homes'}, inplace = True)\nfig = px.line(df, x='DATE', y=df.columns)\nfig.update_xaxes(\n    rangeslider_visible=True,\n    rangeselector=dict(\n        buttons=list([\n            dict(count=6, label=\"6m\", step=\"month\", stepmode=\"backward\"),\n            dict(count=1, label=\"YTD\", step=\"year\", stepmode=\"todate\"),\n            dict(count=1, label=\"1y\", step=\"year\", stepmode=\"backward\"),\n            dict(step=\"all\")\n        ])\n    )\n)\ncolm2.plotly_chart(fig)\n\n#####################\n\nst.header('Household Debt')\ncolm1,colm2 = st.columns((3,4))\ncolm1.write('''\nThere are many types of debt, including household debt, and many specific types of household debt as well. \n\\nThe graph on the right shows Mortgage Debt Service Payments as a Percent of Disposable Personal Income. \n\\nThe financial burdens from mortgages debt vary quite a bit. Let’s consider two reasons for this: The larger \nthe debt, the larger the burden, as households need to pay more interest on a larger principal. And changes \nin interest rates obviously influence how much is paid to service loans.\\n The mortgage debt increased from the early 1990s until the past recession, \nwhen it decreased. This decrease is the result of the combination of the two effects noted above: the amount of debt and interest rates. \nWith one exception (in the fourth quarter of 2012), total debt obligations are at the lowest they’ve been since these data were first \ncollected. And this is especially true of mortgage debt.\n\n''')\n\ndf = pd.read_csv('./data/cleaned/debt_inc.csv')\nfig = px.line(df, x='DATE', y=df.columns)\nfig.update_xaxes(\n    rangeslider_visible=True,\n    rangeselector=dict(\n        buttons=list([\n            dict(count=6, label=\"6m\", step=\"month\", stepmode=\"backward\"),\n            dict(count=1, label=\"YTD\", step=\"year\", stepmode=\"todate\"),\n            dict(count=1, label=\"1y\", step=\"year\", stepmode=\"backward\"),\n            dict(step=\"all\")\n        ])\n    )\n)\ncolm2.plotly_chart(fig)\n\nlabels = ['Mortgage','Student','Others']\nvalues = [10.44, 1.58, 3.22]\n# Use `hole` to create a donut-like pie chart\nfig = go.Figure(data=[go.Pie(labels=labels, values=values, hole=.3)])\n\ncol1,col2 = st.columns((1,2))\nwith col2:\n    st.plotly_chart(fig)\n\nwith col1:\n    st.write('**Mortgage debt as a fraction of total household debt**')\n    st.write('''\n    Mortgage Debt Service Payments as a Percent of Disposable Personal Income was 3.81% in April of 2021, according to the United States Federal Reserve.\\nHistorically, United States - Mortgage Debt Service Payments as a Percent of Disposable Personal Income reached a record high of 7.18 in October of 2007 and a record low of 3.51 in January of 2021. \n    By the end of 2021, a record level of household debt was reached. Mortgage being the biggest contributor to it being 68.5% at 10.44 Trillion Dollars. Student debt was the second highest contributor with 21.1% at 1.58 Trillion Dollars.\n\n    ''')\n\n##############################\n\nst.header('New Single Family Unit Permits 📋')\ncolm1,colm2 = st.columns((3,4))\ncolm1.write('''\n\\nSingle-family housing starts were pridicted to total 1 million in 2020, the highest since 2007. However, \nThere were only approximately 978,000 building permits for single-family housing units granted in the United States in 2020, which is \nan increase of around 116,000 on the previous year. Units have steadily increased since 2011, but the numbers remain considerably \nlower than the 1.68 million authorized by building permits in 2005.\n\\nThat was about 3 years prior to the housing market meltdown that spurred a global financial rout. \n\\nThe rising cost of land, labor, building materials, and regulations, are some of the reasons why we can see significantly more blue (people who may need homes) in the graph below, than orange (total homes built) since 2008. You can also see that few of the new homes built were “starter homes” focused on first-time buyers.\n''')\n\ndf = pd.read_csv('./data/cleaned/permit.csv')\ndf.rename(columns = {'PERMIT1':'No. of permits issued in thousands'}, inplace = True)\ndf.rename(columns = {'HSN1F':'No. of one family homes sold in thousands'}, inplace = True)\nfig = px.line(df, x='DATE', y=df.columns)\nfig.update_xaxes(\n    rangeslider_visible=True,\n    rangeselector=dict(\n        buttons=list([\n            dict(count=6, label=\"6m\", step=\"month\", stepmode=\"backward\"),\n            dict(count=1, label=\"YTD\", step=\"year\", stepmode=\"todate\"),\n            dict(count=1, label=\"1y\", step=\"year\", stepmode=\"backward\"),\n            dict(step=\"all\")\n        ])\n    )\n)\ncolm2.plotly_chart(fig)\ncol1,col2 = st.columns((1,1))\nimg = Image.open('new_perms.png')\nwith col1:\n    st.image(img)\n\nwith col2:\n    st.write('''\n    \\n Even though the new homes built by 2020 were the fastest rate since 2007, Single-family home construction is running at the slowest pace since 1995.\n    \\nThe U.S. is short 5.24 million homes, an increase of 1.4 million from the 2019 gap of 3.84 million.\n    \\nSingle-family home construction has suffered from a severe labor shortage that began well before the pandemic but was then exacerbated by it. Supply chain disruptions in the past year have pushed prices for building materials higher, and as pandemic-induced demand soared, prices for land increased as well. While new household formation is actually slower than it was before the pandemic, homebuilders would have to double their recent new home production pace to close the gap in five to six years. A new household can be either owner-occupied or rented.\n    ''')\n\n################################\n\n\nst.header('Existing Home Sales')\ncolm1,colm2 = st.columns((3,4))\ncolm1.write('''\nThe steady rise in sales after the sharp drop in 2008 is indicative of the general consensus that the housing market is recovering. Construction is showing positive signs, consumers are growing in confidence and are becoming freer with their spending and the market is entering new periods of growth. \n\\n\nThis is a far cry from the dire situation in the not too distant past, in the run up to the bursting of the U.S. housing bubble. Interest rates were very low at that time, making credit cheap and abundantly available. Banks and lending institutions led people to believe that it was okay to buy multiple properties with little money and that real estate was just about the safest investment anyone could make. More and more people decided to take the risk and invest in the market. This coupled with the increased number of people descending on the market caused prices to soar; it seemed like an easy way to make cash fast. But this is how the bubble formed and it was this bubble, upon bursting, that would set into motion a chain of events that would bring the global economy to its knees; plunging the world into an economic depression of which it has not seen the likes since the Great Depression of the 1930s.\n''')\n\ndf = pd.read_csv('./data/cleaned/existinghomessold.csv')\nfig = px.line(df, x='Year', y=df.columns)\nfig.update_xaxes(\n    rangeslider_visible=True,\n    rangeselector=dict(\n        buttons=list([\n            dict(count=6, label=\"6m\", step=\"month\", stepmode=\"backward\"),\n            dict(count=1, label=\"YTD\", step=\"year\", stepmode=\"todate\"),\n            dict(count=1, label=\"1y\", step=\"year\", stepmode=\"backward\"),\n            dict(step=\"all\")\n        ])\n    )\n)\ncolm2.plotly_chart(fig)\ncol1,col2 = st.columns((2,1))\n\nlabels = ['Exisiting Homes Sold','New Homes Sold']\nvalues = [5640000, 822000]\n\nfig = go.Figure(data=[go.Pie(labels=labels, values=values, textinfo='label+percent',\n                             insidetextorientation='radial'\n                            )])\ncol1.plotly_chart(fig)\n\nwith col2:\n    st.write('''\n    **U.S. existing home sales 2005-2023**\n    \\nIn 2021, the U.S. home sales in the United States surged, reaching the highest value observed since 2006. A total of 6.1 million housing transactions were completed in that year, up from 5.6 million in 2020. According to the forecast, sales activity is expected to slow down slightly in 2022 and increase again in 2023. \n    ''')\n\n\n##################################\n\nst.header('Foreclosures 🏦')\ncolm1,colm2 = st.columns((3,4))\ncolm1.write('''\nDespite a deep recession, the U.S. housing market in 2020 set a record for the fewest foreclosures ever.\n\nJust 214,323 properties were in some stage of foreclosure last year, well below the previous low set in 2019, according to ATTOM Data Solutions. Properties with foreclosure filings in 2020 represented a scant 0.16 percent of all U.S. homes, down from a foreclosure rate of 0.36 percent in 2019. The record high was 2.23 percent, in 2010.\n\nIn a separate study released Friday, mortgage data firm Black Knight said foreclosure starts plunged by 67 percent from 2019, while foreclosure sales dropped by 70 percent compared to the previous year.\n\nHowever, the data isn’t all rosy. Fully 2.15 million American homeowners were 90 days past due on their mortgages, a number that rose by 1.7 million during the year of the coronavirus pandemic, Black Knight said.\n\nForeclosures fell not because all was well economically, but because lenders essentially stopped taking back properties in 2020. After the coronavirus pandemic struck in March, federal and state officials hit the pause button on default filings by lenders. And the CARES Act called for mortgage forbearance plans designed to keep struggling workers in their homes.\n''')\n\ndf = pd.read_csv('./data/cleaned/foreclosures.csv')\nfig = px.line(df, x='Year', y=df.columns)\nfig.update_xaxes(\n    rangeslider_visible=True,\n    rangeselector=dict(\n        buttons=list([\n            dict(count=6, label=\"6m\", step=\"month\", stepmode=\"backward\"),\n            dict(count=1, label=\"YTD\", step=\"year\", stepmode=\"todate\"),\n            dict(count=1, label=\"1y\", step=\"year\", stepmode=\"backward\"),\n            dict(step=\"all\")\n        ])\n    )\n)\ncolm2.plotly_chart(fig)\n##\ncol1, col2 = st.columns((2,1))\n\nimg = Image.open('subprime_mort.png')\nwith col1:\n    st.image(img)\n\ncol2.write('''\n    \\n The mortgage delinquency rate is the share of the total number of mortgaged home loans in the U.S. where payment is overdue by 30 days or more. Many borrowers are eventually able to service their loan though, with foreclosure rates being generally 50-75 percent lower than delinquency rates. Total home mortgage debt in the U.S. stood at 10.94 trillion U.S. dollars in 2020. \n    \\n ‘Subprime’ loans, being targeted at high-risk borrowers and generally coupled with higher interest rates to compensate for the risk, have far higher delinquency rates than conventional loans. Defaulting on such loans was one of the triggers for the 2007-2010 financial crisis, with subprime delinquency rates reaching almost 26 percent around this time. These higher delinquency rates translate into higher foreclosure rates, which peaked at just under 15 percent of all subprime mortgages in 2011.\n    ''')\nst.write(\"In the second quarter of 2020, under the effects of the coronavirus crisis, the mortgage delinquency rate in the United States spiked at 8.22 percent, just one percent down from its peak of 9.3 percent during the subprime mortgage crisis of 2007-2010. Following the drastic increase directly after the outbreak of the pandemic, delinquency rates started gradually declining and reached 4.65 percent as of the fourth quarter of 2021. \")\n\n##############################\nst.header('Determining the most influencial factor')\nst.write('''\nTo Determine the most influencial factor of all the forementioned factors, \nall the data for the factors were resampled to a similar time intervals and combined into a single dataframe:\n''')\ndf = pd.read_csv('finalcombined.csv')\nst.dataframe(df)\n\nst.write('Here CUSUSHPISA is the S&P CoreLogic Case-Shiller U.S. National Home Price NSA Index')\n\ndesc = df.describe()\nst.dataframe(desc)\n\n\n\ncorr = df.corr()\ncorr_inf = pd.DataFrame(corr.CSUSHPISA)\n\nst.header(\"Correlation Analysis\")\ncol1,col2 = st.columns((1,1))\ncol1.write('''\n\n''')\ncol1.dataframe(corr_inf,  height=700)\n\n# Generate a mask for the upper triangle\nmask = np.triu(np.ones_like(corr, dtype=bool))\n\n# Set up the matplotlib figure\nf, ax = plt.subplots(figsize=(11, 9))\n\n# Generate a custom diverging colormap\ncmap = sns.diverging_palette(230, 20, as_cmap=True)\n\n# Draw the heatmap with the mask and correct aspect ratio\nfig = plt.subplots()\n\nsns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,\n            square=True, linewidths=.5, cbar_kws={\"shrink\": .5})\nplt.savefig('corr_dia1.png')\nimg = Image.open('corr_dia1.png')\ncol2.image(img)\n\ncol11,col12 = st.columns((2,1))\ncorr_inf_new = corr_inf.head(10)\nfig = px.bar(corr_inf_new)\ncol11.plotly_chart(fig)\ncol12.title(\"_\")\ncol12.write('''\nThis analysis shows how the factors are correlated with the index and amongst themselves. Higher the bars in the graph \n(in magnitude) on the left, the more correlated the factors are with the index. \n\\n For all the plots above the 0 value, there is a positive correlation and vice-versa.\n''')\n\ncol1, col2 = st.columns((2,1))\ncol1.write('''\nThe absolute values indicate the level of correlation and the sign shows the relation, i.e either positive or negative correlation.\n\\n The most correlated factors(in order) are:\n''')\ndata = abs(corr_inf_new)\nsorted_data = data.sort_values(by=['CSUSHPISA'], ascending=False)\nsorted_data_new = corr_inf_new.sort_values(by=['CSUSHPISA'], ascending=False)\ncol2.dataframe(sorted_data, height=700)\ntop_5 = sorted_data.head(5)\n\nst.header(\"Explanatory Regression Analysis\")\n\nst.write('''\nNext, a multiple regression analysis was performed on the cleaned and combined data. Given in the case, in which we would like to predict the prices\nof the index, a multiple regression model would have been created and only the factor(s) influencing it the most would be chosen. Here, only the analysis \nis performed in order to examine whether:\\n 1) Is it better to take all the factors into consideration?\n\\n2) Is it better to take only the top 5 highest correlated data into consideration? \n\\n 3) Is it better to just take one factor into consideration?\n\\n Each of the cases is examined and the output is explained below.\n''')\n##\ncol1,col2 = st.columns((1,1))\n\ncol1.write('''\nCase 1) Building a multiple regression model taking all the factors into consideration:\n''')\n\ncol1.dataframe(corr_inf_new, height=700)\n\nimg_mlr_2 = Image.open('MLR_1.png')\ncol2.image(img_mlr_2)\n##\ncol1.write('''\nCase 2) The asbolute values of the correlation table have been sorted and the 5 factors with the highest correlation are represented in the table\nbelow. When these factors(only) are taken into consideration:\n''')\n\n\ncol1.dataframe(top_5)\n\nimg_mlr_2 = Image.open('MLR_5.png')\ncol2.image(img_mlr_2)\n##\ncol1.write('''\nCase 3) Only the most correlated factor i.e. the population was taken into consideration:\n''')\n\ndata = abs(corr_inf_new)\nsorted_data = data.sort_values(by=['CSUSHPISA'], ascending=False)\ntop_1 = sorted_data.head(1)\ncol1.dataframe(top_1)\n\nimg_mlr_2 = Image.open('MLR_O.png')\ncol2.image(img_mlr_2)\n\n\n##\nst.header(\"Conclusion\")\nst.write('''\nIt is known that for a regression model the R-Squared value always increases and never decres incase the number of variables are increased.\nTo make up for this, the Adjusted R-Squared penalises the R-Squared based on the number of variables. A very low Adjusted R-Square may indicate that some\nof the variables are not contributing. And as we take more variables the R-Squared value rises, which is represented in the above cases. \nHowever, in the case 1, the Adjusted R-Squared value is very low, indicating that there is no variable that is not contributing at all. \n\\n The probablistic F-Static value for case 3 is lesser than that of case 1, indicating that the most correlated field, \"Population\", \ndoes have great influence on the index. This also allows us to conclude, that the results of the correlation analysis are true and are proven here.\nThus, we can say that the most import factors in order influencing the *S&P CoreLogic Case-Shiller U.S. National Home Price NSA Index* are the most \ncorrelated factors. And that Multiple regression analysis is only useful in quantifying relationships in factors when there is a need to do predective\nmodelling and not singling out one most important variable out of multiple variables.\n''')\n\n##############################\nst.header('Biblography 📚')\nhtml_string = '''<html>\n    <head>\n        <title> Biblography </title>\n    </head>\n    <body>\n        <table style=\"border-width: 1;\">\n            <th style=\"background-color:lightgray;\"> Refernces</th>\n            <tr>\n                <td>\n                    <a href=\"http://fred.stlouisfed.org\">fred.stlouisfed.org</a>\n                </td>\n            </tr>\n            <tr>\n                <td>\n                    <a href=\"https://www.statista.com\">statista.com</a>\n                </td>\n            </tr>\n            <tr>\n                <td>\n                    <a href=\"www.opendoor.com\">opendoor.com</a>\n                </td>\n            </tr>\n            <tr>\n                <td>\n                    <a href=\"http://nar.realtor\">nar.realtor</a>\n                </td>\n            </tr>     \n            <tr>\n                <td>\n                    <a href=\"https://tradingeconomics.com/\">tradingeconomics.com</a>\n                </td>\n            </tr>  \n            <tr>\n                <td>\n                    <a href=\"https://data.worldbank.org\">data.worldbank.org</a>\n                </td>\n            </tr>\n            <tr>\n                <td>\n                    <a href=\"https://www.cnbc.com\">cnbc.com</a>\n                </td>\n            </tr>         \n        </table>\n    </body>\n</html>'''\nst.markdown(html_string, unsafe_allow_html=True)\n", "meta": {"hexsha": "2361fb36fbd9669f228a8c221a685026886fd935", "size": 30835, "ext": "py", "lang": "Python", "max_stars_repo_path": "main.py", "max_stars_repo_name": "rishitsaraf/ushousing-datasciencemodel", "max_stars_repo_head_hexsha": "9ab566e327825ba700fd1d1f5ae64c57cb1b246d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "main.py", "max_issues_repo_name": "rishitsaraf/ushousing-datasciencemodel", "max_issues_repo_head_hexsha": "9ab566e327825ba700fd1d1f5ae64c57cb1b246d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "main.py", "max_forks_repo_name": "rishitsaraf/ushousing-datasciencemodel", "max_forks_repo_head_hexsha": "9ab566e327825ba700fd1d1f5ae64c57cb1b246d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 48.7124802528, "max_line_length": 915, "alphanum_fraction": 0.7089346522, "include": true, "reason": "import numpy", "num_tokens": 7569, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.10818895168662, "lm_q1q2_score": 0.05156065284375426}}
{"text": "# SPDX-License-Identifier: Apache-2.0\n\n\"\"\"\nWhat is the opset number?\n=========================\n\n.. index:: opset, target opset, version\n\nEvery library is versioned. :epkg:`scikit-learn` may change\nthe implementation of a specific model. That happens\nfor example with the `SVC <https://scikit-learn.org/stable/\nmodules/generated/sklearn.svm.SVC.html>`_ model where\nthe parameter *break_ties* was added in 0.22. :epkg:`ONNX`\ndoes also have a version called *opset number*.\nOperator *ArgMin* was added in opset 1 and changed in opset\n11, 12, 13. Sometimes, it is updated to extend the list\nof types it supports, sometimes, it moves a parameter\ninto the input list. The runtime used to deploy the model\ndoes not implement a new version, in that case, a model\nmust be converted by usually using the most recent opset\nsupported by the runtime, we call that opset the\n*targeted opset*. An ONNX graph only contains\none unique opset, every node must be described following\nthe specifications defined by the latest opset below the\ntargeted opset.\n\nThis example considers an `IsolationForest\n<https://scikit-learn.org/stable/modules/generated/\nsklearn.ensemble.IsolationForest.html>`_ and digs into opsets.\n\n.. contents::\n    :local:\n\nData\n++++\n\nA simple example.\n\"\"\"\nfrom onnx.defs import onnx_opset_version\nfrom skl2onnx import to_onnx\nimport numpy\nimport matplotlib.pyplot as plt\nfrom sklearn.ensemble import IsolationForest\nfrom sklearn.datasets import make_blobs\n\nX, y = make_blobs(n_samples=100, n_features=2)\n\nmodel = IsolationForest(3)\nmodel.fit(X)\nlabels = model.predict(X)\n\nfig, ax = plt.subplots(1, 1)\nfor k in (0, 1):\n    ax.plot(X[labels == k, 0], X[labels == k, 1], 'o', label=\"cl%d\" % k)\nax.set_title(\"Sample\")\n\n#######################################\n# ONNX\n# ++++\n\n\nonx = to_onnx(model, X[:1].astype(numpy.float32))\nprint(onx)\n\n##########################\n# The last line shows the opsets.\n# Let's extract it.\n\ndomains = onx.opset_import\nfor dom in domains:\n    print(\"domain: %r, version: %r\" % (dom.domain, dom.version))\n\n###################################\n# There are two opsets, one for standard operators,\n# the other for machine learning operators.\n\n########################################\n# ONNX and opset\n# ++++++++++++++\n#\n# The converter can convert a model to an older opset\n# than the default one, from 1 to the last available one.\n\n\ndef get_domain_opset(onx):\n    domains = onx.opset_import\n    res = [{'domain': dom.domain, 'version': dom.version}\n           for dom in domains]\n    return {d['domain']: d['version'] for d in res}\n\n\nfor opset in range(1, onnx_opset_version() + 1):\n    try:\n        onx = to_onnx(model, X[:1].astype(numpy.float32), target_opset=opset)\n    except RuntimeError as e:\n        print('target: %r error: %r' % (opset, e))\n        continue\n    nodes = len(onx.graph.node)\n    print('target: %r --> %s %d' % (opset, get_domain_opset(onx), nodes))\n\n########################################\n# It shows that the model cannot be converted for opset\n# below 5. Operator `Reshape <https://github.com/onnx/\n# onnx/blob/master/docs/Operators.md#Reshape>`_ changed in\n# opset 5: a parameter became an input. The converter\n# does not support *opset < 5* because runtimes usually do not.\n#\n# Other opsets\n# ++++++++++++\n#\n# The previous example changed the opset of the main domain\n# ``''`` but the other opset domain can be changed as well.\n\nfor opset in range(9, onnx_opset_version() + 1):\n    for opset_ml in range(1, 3):\n        tops = {'': opset, 'ai.onnx.ml': opset_ml}\n        try:\n            onx = to_onnx(\n                model, X[:1].astype(numpy.float32), target_opset=tops)\n        except RuntimeError as e:\n            print('target: %r error: %r' % (opset, e))\n            continue\n        nodes = len(onx.graph.node)\n        print('target: %r --> %s %d' % (opset, get_domain_opset(onx), nodes))\n", "meta": {"hexsha": "4af9d9418ce68fc82fd053defe0766daebbce9c1", "size": 3847, "ext": "py", "lang": "Python", "max_stars_repo_path": "docs/tutorial/plot_cbegin_opset.py", "max_stars_repo_name": "Alexsandruss/sklearn-onnx", "max_stars_repo_head_hexsha": "b612557615df439e471867a676c9eca8ae4a787c", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-11T22:08:57.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-11T22:08:57.000Z", "max_issues_repo_path": "docs/tutorial/plot_cbegin_opset.py", "max_issues_repo_name": "ogrisel/sklearn-onnx", "max_issues_repo_head_hexsha": "0afbe295aa3f1abbcea60f582faac31d16bd3ab0", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/tutorial/plot_cbegin_opset.py", "max_forks_repo_name": "ogrisel/sklearn-onnx", "max_forks_repo_head_hexsha": "0afbe295aa3f1abbcea60f582faac31d16bd3ab0", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.776, "max_line_length": 77, "alphanum_fraction": 0.6529763452, "include": true, "reason": "import numpy", "num_tokens": 1041, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4263215925474903, "lm_q2_score": 0.12085323090725615, "lm_q1q2_score": 0.05152234186489102}}
{"text": "\"\"\"\nPoints\n\nTESTS::\n\n    sage: E = EllipticCurve('37a')\n    sage: P = E(0,0)\n    sage: def get_points(n): return sum([point(list(i*P)[:2], size=3) for i in range(-n,n) if i != 0 and (i*P)[0] < 3])\n    sage: sum([get_points(15*n).plot3d(z=n) for n in range(1,10)])\n    Graphics3d Object\n\"\"\"\n\n#*****************************************************************************\n#       Copyright (C) 2006 Alex Clemesha <clemesha@gmail.com>,\n#                          William Stein <wstein@gmail.com>,\n#                     2008 Mike Hansen <mhansen@gmail.com>,\n#\n#  Distributed under the terms of the GNU General Public License (GPL)\n#\n#    This code is distributed in the hope that it will be useful,\n#    but WITHOUT ANY WARRANTY; without even the implied warranty of\n#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n#    General Public License for more details.\n#\n#  The full text of the GPL is available at:\n#\n#                  http://www.gnu.org/licenses/\n#*****************************************************************************\nfrom sage.misc.decorators import options, rename_keyword\nfrom sage.plot.colors import to_mpl_color\nfrom sage.plot.primitive import GraphicPrimitive_xydata\nimport collections\n\n\n# TODO: create _allowed_options for 3D point classes to\n# improve bad option handling in plot3d?\nclass Point(GraphicPrimitive_xydata):\n    \"\"\"\n    Primitive class for the point graphics type.  See point?, point2d?\n    or point3d? for information about actually plotting points.\n\n    INPUT:\n\n    - xdata - list of x values for points in Point object\n\n    - ydata - list of y values for points in Point object\n\n    - options - dict of valid plot options to pass to constructor\n\n    EXAMPLES:\n\n    Note this should normally be used indirectly via ``point`` and friends::\n\n        sage: from sage.plot.point import Point\n        sage: P = Point([1,2],[2,3],{'alpha':.5})\n        sage: P\n        Point set defined by 2 point(s)\n        sage: P.options()['alpha']\n        0.500000000000000\n        sage: P.xdata\n        [1, 2]\n\n    TESTS:\n\n    We test creating a point::\n\n        sage: point((3,3))\n        Graphics object consisting of 1 graphics primitive\n    \"\"\"\n    def __init__(self, xdata, ydata, options):\n        \"\"\"\n        Initializes base class Point.\n\n        EXAMPLES::\n\n            sage: P = point((3,4))\n            sage: P[0].xdata\n            [3.0]\n            sage: P[0].options()['alpha']\n            1\n        \"\"\"\n        self.xdata = xdata\n        self.ydata = ydata\n        GraphicPrimitive_xydata.__init__(self, options)\n\n    def _allowed_options(self):\n        \"\"\"\n        Return the allowed options for the Point class.\n\n        EXAMPLES::\n\n            sage: P = point((3,4))\n            sage: P[0]._allowed_options()['size']\n            'How big the point is (i.e., area in points^2=(1/72 inch)^2).'\n        \"\"\"\n        return {'alpha':'How transparent the point is.',\n                'faceted': 'If True color the edge of the point. (only for 2D plots)',\n                'hue':'The color given as a hue.',\n                'legend_color':'The color of the legend text',\n                'legend_label':'The label for this item in the legend.',\n                'marker':'the marker symbol for 2D plots only (see documentation of plot() for details)',\n                'markeredgecolor':'the color of the marker edge (only for 2D plots)',\n                'rgbcolor':'The color as an RGB tuple.',\n                'size': 'How big the point is (i.e., area in points^2=(1/72 inch)^2).',\n                'zorder':'The layer level in which to draw'}\n\n    def _plot3d_options(self, options=None):\n        \"\"\"\n        Translate 2D plot options into 3D plot options.\n\n        EXAMPLES::\n\n            sage: A=point((1,1),size=22)\n            sage: a=A[0];a\n            Point set defined by 1 point(s)\n            sage: b=a.plot3d()\n            sage: b.size\n            22\n            sage: b=a.plot3d(size=3)\n            sage: b.size\n            3\n        \"\"\"\n        if options is None:\n            options = dict(self.options())\n        options_3d = {}\n        if 'size' in options:\n            options_3d['size'] = options['size']\n            del options['size']\n        if options.pop('faceted', False):\n            raise NotImplementedError(\"3D points can not be faceted.\")\n        for o in ('marker', 'markeredgecolor'): # remove 2D options\n            if o in options:\n                del options[o]\n\n        options_3d.update(GraphicPrimitive_xydata._plot3d_options(self, options))\n        return options_3d\n\n    def plot3d(self, z=0, **kwds):\n        \"\"\"\n        Plots a two-dimensional point in 3-D, with default height zero.\n\n        INPUT:\n\n\n        -  ``z`` - optional 3D height above `xy`-plane.  May be a list\n           if self is a list of points.\n\n        EXAMPLES:\n\n        One point::\n\n            sage: A=point((1,1))\n            sage: a=A[0];a\n            Point set defined by 1 point(s)\n            sage: b=a.plot3d()\n\n        One point with a height::\n\n            sage: A=point((1,1))\n            sage: a=A[0];a\n            Point set defined by 1 point(s)\n            sage: b=a.plot3d(z=3)\n            sage: b.loc[2]\n            3.0\n\n        Multiple points::\n\n            sage: P=point([(0,0), (1,1)])\n            sage: p=P[0]; p\n            Point set defined by 2 point(s)\n            sage: q=p.plot3d(size=22)\n\n        Multiple points with different heights::\n\n            sage: P=point([(0,0), (1,1)])\n            sage: p=P[0]\n            sage: q=p.plot3d(z=[2,3])\n            sage: q.all[0].loc[2]\n            2.0\n            sage: q.all[1].loc[2]\n            3.0\n\n        Note that keywords passed must be valid point3d options::\n\n            sage: A=point((1,1),size=22)\n            sage: a=A[0];a\n            Point set defined by 1 point(s)\n            sage: b=a.plot3d()\n            sage: b.size\n            22\n            sage: b=a.plot3d(pointsize=23) # only 2D valid option\n            sage: b.size\n            22\n            sage: b=a.plot3d(size=23) # correct keyword\n            sage: b.size\n            23\n\n        TESTS:\n\n        Heights passed as a list should have same length as\n        number of points::\n\n            sage: P=point([(0,0), (1,1), (2,3)])\n            sage: p=P[0]\n            sage: q=p.plot3d(z=2)\n            sage: q.all[1].loc[2]\n            2.0\n            sage: q=p.plot3d(z=[2,-2])\n            Traceback (most recent call last):\n            ...\n            ValueError: Incorrect number of heights given\n        \"\"\"\n        from sage.plot.plot3d.base import Graphics3dGroup\n        from sage.plot.plot3d.shapes2 import point3d\n        options = self._plot3d_options()\n        options.update(kwds)\n        zdata=[]\n        if isinstance(z, list):\n            zdata=z\n        else:\n            zdata=[z]*len(self.xdata)\n        if len(zdata)==len(self.xdata):\n            all = [point3d([(x, y, z) for x, y, z in zip(self.xdata, self.ydata, zdata)], **options)]\n            if len(all) == 1:\n                return all[0]\n            else:\n                return Graphics3dGroup(all)\n        else:\n            raise ValueError('Incorrect number of heights given')\n\n    def _repr_(self):\n        \"\"\"\n        String representation of Point primitive.\n\n        EXAMPLES::\n\n            sage: P=point([(0,0), (1,1)])\n            sage: p=P[0]; p\n            Point set defined by 2 point(s)\n        \"\"\"\n        return \"Point set defined by %s point(s)\"%len(self.xdata)\n\n    def __getitem__(self, i):\n        \"\"\"\n        Returns tuple of coordinates of point.\n\n        EXAMPLES::\n\n            sage: P=point([(0,0), (1,1), (2,3)])\n            sage: p=P[0]; p\n            Point set defined by 3 point(s)\n            sage: p[1]\n            (1.0, 1.0)\n        \"\"\"\n        return self.xdata[i], self.ydata[i]\n\n    def _render_on_subplot(self,subplot):\n        r\"\"\"\n        TESTS:\n\n        We check to make sure that :trac:`2076` is fixed by verifying all\n        the points are red::\n\n            sage: point(((1,1), (2,2), (3,3)), rgbcolor=hue(1), size=30)\n            Graphics object consisting of 1 graphics primitive\n        \"\"\"\n        options = self.options()\n\n        #Convert the color to a hex string so that the scatter\n        #method does not interpret it as a list of 3 floating\n        #point color specifications when there are\n        #three points. This is mentioned in the matplotlib 0.98\n        #documentation and fixes \\#2076\n        from matplotlib.colors import rgb2hex\n        c = rgb2hex(to_mpl_color(options['rgbcolor']))\n\n        a = float(options['alpha'])\n        z = int(options.pop('zorder', 0))\n        s = int(options['size'])\n        faceted = options['faceted'] #faceted=True colors the edge of point\n        markeredgecolor = options['markeredgecolor']\n\n        scatteroptions={}\n        if not faceted and markeredgecolor is None:\n            scatteroptions['edgecolors'] = 'none'\n        elif markeredgecolor is not None:\n            scatteroptions['edgecolors'] = to_mpl_color(\n                                              options.pop('markeredgecolor'))\n        scatteroptions['marker'] = options.pop('marker')\n\n        subplot.scatter(self.xdata, self.ydata, s=s, c=c, alpha=a, zorder=z,\n                        label=options['legend_label'], **scatteroptions)\n\n\ndef point(points, **kwds):\n    \"\"\"\n    Returns either a 2-dimensional or 3-dimensional point or sum of points.\n\n    INPUT:\n\n    -  ``points`` - either a single point (as a tuple), a list of\n       points, a single complex number, or a list of complex numbers.\n\n    For information regarding additional arguments, see either point2d?\n    or point3d?.\n\n    .. SEEALSO::\n\n        :func:`sage.plot.point.point2d`, :func:`sage.plot.plot3d.shapes2.point3d`\n\n    EXAMPLES::\n\n        sage: point((1,2))\n        Graphics object consisting of 1 graphics primitive\n\n    ::\n\n        sage: point((1,2,3))\n        Graphics3d Object\n\n    ::\n\n        sage: point([(0,0), (1,1)])\n        Graphics object consisting of 1 graphics primitive\n\n    ::\n\n        sage: point([(0,0,1), (1,1,1)])\n        Graphics3d Object\n\n    Extra options will get passed on to show(), as long as they are valid::\n\n        sage: point([(cos(theta), sin(theta)) for theta in srange(0, 2*pi, pi/8)], frame=True)\n        Graphics object consisting of 1 graphics primitive\n        sage: point([(cos(theta), sin(theta)) for theta in srange(0, 2*pi, pi/8)]).show(frame=True) # These are equivalent\n\n    TESTS:\n\n    One can now use iterators (:trac:`13890`)::\n\n        sage: point(iter([(1,1,1)]))\n        Graphics3d Object\n        sage: point(iter([(1,2),(3,5)]))\n        Graphics object consisting of 1 graphics primitive\n    \"\"\"\n    if isinstance(points, collections.Iterator):\n        points = list(points)\n\n    try:\n        return point2d(points, **kwds)\n    except (ValueError, TypeError):\n        from sage.plot.plot3d.shapes2 import point3d\n        return point3d(points, **kwds)\n\n@rename_keyword(color='rgbcolor', pointsize='size')\n@options(alpha=1, aspect_ratio='automatic', faceted=False,\n        legend_color=None, legend_label=None, marker='o',\n        markeredgecolor=None, rgbcolor=(0,0,1), size=10)\ndef point2d(points, **options):\n    r\"\"\"\n    A point of size ``size`` defined by point = `(x,y)`.\n\n    INPUT:\n\n    -  ``points`` - either a single point (as a tuple), a list of\n       points, a single complex number, or a list of complex numbers.\n    - ``alpha`` -- How transparent the point is.\n    - ``faceted`` -- If True color the edge of the point. (only for 2D plots)\n    - ``hue`` -- The color given as a hue.\n    - ``legend_color`` -- The color of the legend text\n    - ``legend_label`` -- The label for this item in the legend.\n    - ``marker`` -- the marker symbol for 2D plots only (see documentation of\n      :func:`plot` for details)\n    - ``markeredgecolor`` -- the color of the marker edge (only for 2D plots)\n    - ``rgbcolor`` -- The color as an RGB tuple.\n    - ``size`` -- How big the point is (i.e., area in points^2=(1/72 inch)^2).\n    - ``zorder`` -- The layer level in which to draw\n\n    EXAMPLES:\n\n    A purple point from a single tuple or coordinates::\n\n        sage: point((0.5, 0.5), rgbcolor=hue(0.75))\n        Graphics object consisting of 1 graphics primitive\n\n    Points with customized markers and edge colors::\n\n        sage: r = [(random(), random()) for _ in range(10)]\n        sage: point(r, marker='d', markeredgecolor='red', size=20)\n        Graphics object consisting of 1 graphics primitive\n\n    Passing an empty list returns an empty plot::\n\n        sage: point([])\n        Graphics object consisting of 0 graphics primitives\n        sage: import numpy; point(numpy.array([]))\n        Graphics object consisting of 0 graphics primitives\n\n    If you need a 2D point to live in 3-space later, this is possible::\n\n        sage: A=point((1,1))\n        sage: a=A[0];a\n        Point set defined by 1 point(s)\n        sage: b=a.plot3d(z=3)\n\n    This is also true with multiple points::\n\n        sage: P=point([(0,0), (1,1)])\n        sage: p=P[0]\n        sage: q=p.plot3d(z=[2,3])\n\n    Here are some random larger red points, given as a list of tuples::\n\n        sage: point(((0.5, 0.5), (1, 2), (0.5, 0.9), (-1, -1)), rgbcolor=hue(1), size=30)\n        Graphics object consisting of 1 graphics primitive\n\n    And an example with a legend::\n\n        sage: point((0,0), rgbcolor='black', pointsize=40, legend_label='origin')\n        Graphics object consisting of 1 graphics primitive\n\n    The legend can be colored::\n\n        sage: P = points([(0,0),(1,0)], pointsize=40, legend_label='origin', legend_color='red')\n        sage: P + plot(x^2,(x,0,1), legend_label='plot', legend_color='green')\n        Graphics object consisting of 2 graphics primitives\n\n    Extra options will get passed on to show(), as long as they are valid::\n\n        sage: point([(cos(theta), sin(theta)) for theta in srange(0, 2*pi, pi/8)], frame=True)\n        Graphics object consisting of 1 graphics primitive\n        sage: point([(cos(theta), sin(theta)) for theta in srange(0, 2*pi, pi/8)]).show(frame=True) # These are equivalent\n\n    For plotting data, we can use a logarithmic scale, as long as we are sure\n    not to include any nonpositive points in the logarithmic direction::\n\n        sage: point([(1,2),(2,4),(3,4),(4,8),(4.5,32)],scale='semilogy',base=2)\n        Graphics object consisting of 1 graphics primitive\n\n    Since Sage Version 4.4 (:trac:`8599`), the size of a 2d point can be\n    given by the argument ``size`` instead of ``pointsize``. The argument\n    ``pointsize`` is still supported::\n\n        sage: point((3,4), size=100)\n        Graphics object consisting of 1 graphics primitive\n\n    ::\n\n        sage: point((3,4), pointsize=100)\n        Graphics object consisting of 1 graphics primitive\n\n    We can plot a single complex number::\n\n        sage: point(CC(1+I), pointsize=100)\n        Graphics object consisting of 1 graphics primitive\n\n    We can also plot a list of complex numbers::\n\n        sage: point([CC(I), CC(I+1), CC(2+2*I)], pointsize=100)\n        Graphics object consisting of 1 graphics primitive\n\n    \"\"\"\n    from sage.plot.plot import xydata_from_point_list\n    from sage.plot.all import Graphics\n    from sage.rings.all import CC, CDF\n    if points in CC or points in CDF:\n        pass\n    else:\n        try:\n            l = len(points)\n        except TypeError:\n            # argument is an iterator\n            points = list(points)\n            l = len(points)\n\n        if l == 0:\n            return Graphics()\n\n    xdata, ydata = xydata_from_point_list(points)\n    g = Graphics()\n    g._set_extra_kwds(Graphics._extract_kwds_for_show(options))\n    g.add_primitive(Point(xdata, ydata, options))\n    if options['legend_label']:\n        g.legend(True)\n        g._legend_colors = [options['legend_color']]\n    return g\n\npoints = point\n", "meta": {"hexsha": "fbd64ebb6d694fdc48f83adacfed0987c8601933", "size": 15850, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/sage/plot/point.py", "max_stars_repo_name": "switzel/sage", "max_stars_repo_head_hexsha": "7eb8510dacf61b691664cd8f1d2e75e5d473e5a0", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/sage/plot/point.py", "max_issues_repo_name": "switzel/sage", "max_issues_repo_head_hexsha": "7eb8510dacf61b691664cd8f1d2e75e5d473e5a0", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sage/plot/point.py", "max_forks_repo_name": "switzel/sage", "max_forks_repo_head_hexsha": "7eb8510dacf61b691664cd8f1d2e75e5d473e5a0", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-07-24T12:20:37.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-24T12:20:37.000Z", "avg_line_length": 32.4130879346, "max_line_length": 122, "alphanum_fraction": 0.5712302839, "include": true, "reason": "import numpy,from sage", "num_tokens": 4064, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4687906266262437, "lm_q2_score": 0.10970576369015277, "lm_q1q2_score": 0.05142903370481733}}
{"text": "#################################################################################\r\n# The Institute for the Design of Advanced Energy Systems Integrated Platform\r\n# Framework (IDAES IP) was produced under the DOE Institute for the\r\n# Design of Advanced Energy Systems (IDAES), and is copyright (c) 2018-2021\r\n# by the software owners: The Regents of the University of California, through\r\n# Lawrence Berkeley National Laboratory,  National Technology & Engineering\r\n# Solutions of Sandia, LLC, Carnegie Mellon University, West Virginia University\r\n# Research Corporation, et al.  All rights reserved.\r\n#\r\n# Please see the files COPYRIGHT.md and LICENSE.md for full copyright and\r\n# license information.\r\n#################################################################################\r\nfrom enum import Enum\r\nimport subprocess\r\nfrom io import StringIO\r\nimport sys\r\nimport os\r\nimport numpy as np\r\nimport pandas as pd\r\nimport json\r\n\r\nfrom pyomo.environ import Constraint, value, sin, cos, log, exp, Set, Reals\r\nfrom pyomo.common.config import ConfigValue, In, Path, ListOf, Bool\r\nfrom pyomo.common.tee import TeeStream\r\nfrom pyomo.common.fileutils import Executable\r\nfrom pyomo.common.tempfiles import TempfileManager\r\n\r\nfrom idaes.core.surrogate.base.surrogate_base import SurrogateTrainer, SurrogateBase\r\nfrom idaes.core.util.exceptions import ConfigurationError\r\nimport idaes.logger as idaeslog\r\n\r\n\r\n# Set up logger\r\n_log = idaeslog.getLogger(__name__)\r\n\r\n# TODO: Adaptive sampling\r\n\r\nalamo = Executable(\"alamo\")\r\n\r\n# Define mapping of Pyomo function names for expression evaluation\r\nGLOBAL_FUNCS = {\"sin\": sin, \"cos\": cos, \"log\": log, \"exp\": exp}\r\n\r\n\r\n# The values associated with these must match those expected in the .alm file\r\nclass Modelers(Enum):\r\n    BIC = 1\r\n    MallowsCp = 2\r\n    AICc = 3\r\n    HQC = 4\r\n    MSE = 5\r\n    SSEP = 6\r\n    RIC = 7\r\n    MADp = 8\r\n\r\n\r\nclass Screener(Enum):\r\n    none = 0\r\n    lasso = 1\r\n    SIS = 2\r\n\r\n\r\nsupported_options = [\r\n    \"xfactor\",\r\n    \"xscaling\",\r\n    \"scalez\",\r\n    \"monomialpower\",\r\n    \"multi2power\",\r\n    \"multi3power\",\r\n    \"ratiopower\",\r\n    \"expfcns\",\r\n    \"linfcns\",\r\n    \"logfcns\",\r\n    \"sinfcns\",\r\n    \"cosfcns\",\r\n    \"constant\",\r\n    \"grbfcns\",\r\n    \"rbfparam\",\r\n    \"modeler\",\r\n    \"builder\",\r\n    \"backstepper\",\r\n    \"convpen\",\r\n    \"screener\",\r\n    \"ncvf\",\r\n    \"sismult\",\r\n    \"maxtime\",\r\n    \"maxiter\",\r\n    \"datalimitterms\",\r\n    \"maxterms\",\r\n    \"minterms\",\r\n    \"numlimitbasis\",\r\n    \"exclude\",\r\n    \"ignore\",\r\n    \"xisint\",\r\n    \"zisint\",\r\n    \"tolrelmetric\",\r\n    \"tolabsmetric\",\r\n    \"tolmeanerror\",\r\n    \"tolsse\",\r\n    \"mipoptca\",\r\n    \"mipoptcr\",\r\n    \"linearerror\",\r\n    \"GAMS\",\r\n    \"GAMSSOLVER\",\r\n    \"solvemip\",\r\n    \"print_to_screen\",\r\n]\r\n\r\n\"\"\"\r\nExcluded Options:\r\nNSAMPLE, NVALSAMPLE, INITIALIZER, PRINT TO FILE, FUNFORM, NTRANS\r\n\r\nExcluded Simulator options:\r\nMAXSIM, MINPOINTS, MAXPOINTS, SAMPLER, SIMULATOR, PRESET, TOLMAXERROR, SIMIN,\r\nSIMOUT\r\n\"\"\"\r\n\r\n\r\n# Headers from ALAMO trace file that should be common for all outputs\r\ncommon_trace = [\r\n    \"filename\",\r\n    \"NINPUTS\",\r\n    \"NOUTPUTS\",\r\n    \"INITIALPOINTS\",\r\n    \"SET\",\r\n    \"INITIALIZER\",\r\n    \"SAMPLER\",\r\n    \"MODELER\",\r\n    \"BUILDER\",\r\n    \"GREEDYBUILD\",\r\n    \"BACKSTEPPER\",\r\n    \"GREEDYBACK\",\r\n    \"REGULARIZER\",\r\n    \"SOLVEMIP\",\r\n]\r\n\r\n\r\nclass AlamoTrainer(SurrogateTrainer):\r\n    \"\"\"\r\n    Standard SurrogateTrainer for ALAMO.\r\n\r\n    This defines a set of configuration options for ALAMO along with\r\n    methods to read and write the ALAMO input and output files and to call\r\n    the ALAMO executable.\r\n\r\n    Generally, options default to None to indicate that no entry will be\r\n    written in the ALAMO input file. In this case, the default ALAMO settings\r\n    will be used.\r\n    \"\"\"\r\n\r\n    # The following ALAMO options are not (yet) supported\r\n    # Returning model prediction, as we can do that in IDAES\r\n    # Iniital sampling of data, as SurrogateModelTrainer should do that\r\n    # Similarly, adaptive sampling is better handled in Python\r\n    # Single validation set, due to limitations of current API\r\n    # Custom basis functions are not yet implemented\r\n\r\n    CONFIG = SurrogateTrainer.CONFIG()\r\n\r\n    CONFIG.declare(\r\n        \"xfactor\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(float),\r\n            description=\"List of scaling factors for input variables.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"xscaling\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=Bool,\r\n            description=\"Option to scale input variables.\",\r\n            doc=\"Option to scale input variables. If True and xfactors are not \"\r\n            \"provided, ALAMO sets XFACTORS equal to the range of each input \"\r\n            \"variable.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"scalez\",\r\n        ConfigValue(\r\n            default=None, domain=Bool, description=\"Option to scale output variables.\"\r\n        ),\r\n    )\r\n\r\n    # Basis function options\r\n    CONFIG.declare(\r\n        \"monomialpower\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(\r\n                int, In(Reals - {0, 1})\r\n            ),  # allow any float except for 0 and 1\r\n            description=\"Vector of monomial powers considered in basis \"\r\n            \"functions - cannot include 0 or 1.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"multi2power\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(float),\r\n            description=\"Vector of powers to be considered for pairwise \"\r\n            \"combinations in basis functions.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"multi3power\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(float),\r\n            description=\"Vector of three variable combinations of powers to be \"\r\n            \"considered as basis functions.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"ratiopower\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(float),\r\n            description=\"Vector of ratio combinations of powers to be considered \"\r\n            \"in the basis functions.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"constant\",\r\n        ConfigValue(\r\n            default=True,\r\n            domain=Bool,\r\n            description=\"Include constant basis function if True. Default = True\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"linfcns\",\r\n        ConfigValue(\r\n            default=True,\r\n            domain=Bool,\r\n            description=\"Include linear basis functions if True. Default = True\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"expfcns\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=Bool,\r\n            description=\"Include exponential basis functions if True.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"logfcns\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=Bool,\r\n            description=\"Include logarithmic basis functions if True.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"sinfcns\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=Bool,\r\n            description=\"Include sine basis functions if True.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"cosfcns\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=Bool,\r\n            description=\"Include cosine basis functions if True.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"grbfcns\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=Bool,\r\n            description=\"Include Gaussian radial basis functions if True.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"rbfparam\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=float,\r\n            description=\"Multiplicative constant used in the Gaussian radial basis\"\r\n            \" functions.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"custom_basis_functions\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(str),\r\n            description=\"List of custom basis functions to include in surrogate \"\r\n            \"fitting.\",\r\n            doc=\"List of custom basis functions to include in surrogate model \"\r\n            \"fitting. These should be in a form that can be rendered as a string \"\r\n            \"that meets ALAMO's requirements.\",\r\n        ),\r\n    )\r\n\r\n    # Other fitting options\r\n    CONFIG.declare(\r\n        \"modeler\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=In(Modelers),\r\n            description=\"Fitness metric to be used for model building. Must be an \"\r\n            \"instance of Modelers Enum.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"builder\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=Bool,\r\n            description=\"If True, a greedy heuristic builds up a model \"\r\n            \"by adding one variable at a time.\",\r\n            doc=\"If True, a greedy heuristic builds up a model by adding one \"\r\n            \"variable at a time. This model is used as a starting point for \"\r\n            \"solving an integer programming formulation according to the choice \"\r\n            \"of modeler. If an optimizer is not available, the heuristic model \"\r\n            \"will be the final model to be returned.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"backstepper\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=Bool,\r\n            description=\"If set to 1, a greedy heuristic builds down a model by \"\r\n            \"starting from the least squares model and removing one variable at \"\r\n            \"a time.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"convpen\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=float,\r\n            description=\"Convex penalty term to use if Modeler == SSEP or MADp.\",\r\n            doc=\"When MODELER is set to 6 or 8, a penalty consisting of the sum \"\r\n            \"of square errors (SSEP) or the maximum absolute error (MADp) and a \"\r\n            \"term penalizing model size is used for model building. The size of \"\r\n            \"the model is weighted by convpen. If convpen=0, this metric reduces \"\r\n            \"to the classical sum of square errors (SSEP) or the maximum absolute \"\r\n            \"deviation (MADp).\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"screener\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=In(Screener),\r\n            description=\"Regularization method used to reduce the number of \"\r\n            \"potential basis functions before optimization. Must be instance of \"\r\n            \"Screener Enum.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"ncvf\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=int,\r\n            description=\"Number of folds to be used for cross validation by the \"\r\n            \"lasso screener. ALAMO will use a two-fold validation if fewer than \"\r\n            \"10 data points are available. NCVF must be a nonnegative integer.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"sismult\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=int,\r\n            description=\"This parameter must be non-negative and is used to \"\r\n            \"determine the number of basis functions retained by the SIS \"\r\n            \"screener. The number of basis functions retained equals the floor \"\r\n            \"of SSISmult n ln(n), where n is the number of measurements \"\r\n            \"available at the current ALAMO iteration.\",\r\n        ),\r\n    )\r\n\r\n    CONFIG.declare(\r\n        \"maxiter\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=int,\r\n            description=\"Maximum number of ALAMO iterations. 1 = no adaptive \"\r\n            \"sampling, 0 = no limit.\",\r\n            doc=\"Maximum number of ALAMO iterations. Each iteration begins with \"\r\n            \"a model-building step. An adaptive sampling step follows if maxiter \"\r\n            \"does not equal 1. If maxiter is set to a number less than or equal \"\r\n            \"to 0, ALAMO will enforce no limit on the number of iterations.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"maxtime\",\r\n        ConfigValue(\r\n            default=1000,\r\n            domain=float,\r\n            description=\"Maximum total execution time allowed in seconds. \"\r\n            \"Default = 1000.\",\r\n            doc=\"Maximum total execution time allowed in seconds. This time \"\r\n            \"includes all steps of the algorithm, including time to read problem, \"\r\n            \"preprocess data, solve optimization subproblems, and print results.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"datalimitterms\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=Bool,\r\n            description=\"Limit model terms to number of measurements.\",\r\n            doc=\"If True, ALAMO will limit the number of terms in the model to be \"\r\n            \"no more than the number of data measurements; otherwise, no limit \"\r\n            \"based on the number of data measurements will be placed. The user \"\r\n            \"may provide an additional limit on the number of terms in the model \"\r\n            \"through the maxterms and minterms options.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"maxterms\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(int),\r\n            description=\"List of maximum number of model terms to per output.\",\r\n            doc=\"Row vector of maximum terms allowed in the modeling of output \"\r\n            \"variables. One per output variable, space separated. A −1 signals \"\r\n            \"that no limit is imposed.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"minterms\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(int),\r\n            description=\"List of minimum number of model terms to per output.\",\r\n            doc=\"Row vector of minimum terms required in the modeling of output \"\r\n            \"variables. One per output variable, space separated. A 0 signals \"\r\n            \"that no limit is imposed.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"numlimitbasis\",\r\n        ConfigValue(\r\n            default=True,  # default this to true to avoid numerical issues\r\n            domain=Bool,\r\n            description=\"Eliminate infeasible basis functions. Default = True\",\r\n            doc=\"If True, ALAMO will eliminate basis functions that are not \"\r\n            \"numerically acceptable (e.g., log(x) will be eliminated if x may be \"\r\n            \"negative); otherwise, no limit based on the number of data \"\r\n            \"measurements will be placed. The user may provide additional limits \"\r\n            \"on the the type and number of selected basis functions through the \"\r\n            \"options exclude and groupcon.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"exclude\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(int),\r\n            description=\"List of inputs to exclude during building,\",\r\n            doc=\"Row vector of 0/1 flags that specify which input variables, if \"\r\n            \"any, ALAMO should exclude during the model building process. All \"\r\n            \"input variables must be present in the data but ALAMO will not \"\r\n            \"include basis functions that involve input variables for which \"\r\n            \"exclude equals 1. This feature does not apply to custom basis \"\r\n            \"functions or RBFs.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"ignore\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(int),\r\n            description=\"List of outputs to ignore during building.\",\r\n            doc=\"Row vector of 0/1 flags that specify which output variables, \"\r\n            \"if any, ALAMO should ignore. All output variables must be present in \"\r\n            \"the data but ALAMO does not model output variables for which ignore \"\r\n            \"equals 1.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"xisint\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(int),\r\n            description=\"List of inputs that should be treated as integers.\",\r\n            doc=\"Row vector of 0/1 flags that specify which input variables, if \"\r\n            \"any, ALAMO should treat as integers. For integer inputs, ALAMO’s \"\r\n            \"sampling will be restricted to integer values.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"zisint\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(int),\r\n            description=\"List of outputs that should be treated as integers.\",\r\n            doc=\"Row vector of 0/1 flags that specify which output variables, if \"\r\n            \"any, ALAMO should treat as integers. For integer variables, ALAMO’s \"\r\n            \"model will include the rounding of a function to the nearest integer \"\r\n            \"(equivalent to the nint function in Fortran.)\",\r\n        ),\r\n    )\r\n\r\n    CONFIG.declare(\r\n        \"tolrelmetric\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(float),\r\n            description=\"Relative tolerance for outputs.\",\r\n            doc=\"Relative convergence tolerance for the chosen fitness metric for \"\r\n            \"the modeling of output variables. One per output variable, space \"\r\n            \"separated. Incremental model building will stop if two consecutive \"\r\n            \"iterations do not improve the chosen metric by at least this amount.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"tolabsmetric\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(float),\r\n            description=\"Absolute tolerance for outputs.\",\r\n            doc=\"Absolute convergence tolerance for the chosen fitness metric for \"\r\n            \"the modeling of output variables. One per output variable, space \"\r\n            \"separated. Incremental model building will stop if two consecutive \"\r\n            \"iterations do not improve the chosen metric by at least this amount.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"tolmeanerror\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=ListOf(float),\r\n            description=\"Convergence tolerance for mean errors in outputs.\",\r\n            doc=\"Row vector of convergence tolerances for mean errors in the \"\r\n            \"modeling of output variables. One per output variable, space \"\r\n            \"separated. Incremental model building will stop if tolmeanerror, \"\r\n            \"tolrelmetric, or tolabsmetric is satisfied.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"tolsse\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=float,\r\n            description=\"Absolute tolerance on SSE\",\r\n            doc=\"Absolute tolerance on sum of square errors (SSE). ALAMO will \"\r\n            \"terminate if it finds a solution whose SSE is within tolsse from \"\r\n            \"the SSE of the full least squares problem.\",\r\n        ),\r\n    )\r\n\r\n    CONFIG.declare(\r\n        \"mipoptca\",\r\n        ConfigValue(\r\n            default=None, domain=float, description=\"Absolute tolerance for MIP.\"\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"mipoptcr\",\r\n        ConfigValue(\r\n            default=None, domain=float, description=\"Relative tolerance for MIP.\"\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"linearerror\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=Bool,\r\n            description=\"If True, a linear objective is used when solving \"\r\n            \"mixed-integer optimization problems; otherwise, a squared error will \"\r\n            \"be employed.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"GAMS\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=str,\r\n            description=\"Complete path of GAMS executable (or name if GAMS is in \"\r\n            \"the user path).\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"GAMSSOLVER\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=str,\r\n            description=\"Name of preferred GAMS solver for solving ALAMO’s \"\r\n            \"mixed-integer quadratic subproblems. Special facilities have been \"\r\n            \"implemented in ALAMO and BARON that make BARON the preferred \"\r\n            \"selection for this option. However, any mixed-integer quadratic \"\r\n            \"programming solver available under GAMS can be used.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"solvemip\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=Bool,\r\n            description=\"Whether to use an optimizer to solve MIP.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"print_to_screen\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=Bool,\r\n            description=\"Send ALAMO output to stdout. Output is returned by the \"\r\n            \"call_alamo method.\",\r\n        ),\r\n    )\r\n\r\n    # I/O file options\r\n    CONFIG.declare(\r\n        \"alamo_path\",\r\n        ConfigValue(\r\n            default=None, domain=Path, doc=\"Path to ALAMO executable (if not in path).\"\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"filename\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=str,\r\n            description=\"File name to use for ALAMO files - must be full path of a\"\r\n            \" .alm file. Other files will be defined from this pattern. If this \"\r\n            \"option is not None, then working files will not be deleted.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"working_directory\",\r\n        ConfigValue(\r\n            default=None,\r\n            domain=str,\r\n            description=\"Full path to working directory for ALAMO to use. \"\r\n            \"If this option is not None, then working files will not be deleted.\",\r\n        ),\r\n    )\r\n    CONFIG.declare(\r\n        \"overwrite_files\",\r\n        ConfigValue(\r\n            default=False,\r\n            domain=Bool,\r\n            description=\"Flag indicating whether existing files can be \" \"overwritten.\",\r\n        ),\r\n    )\r\n\r\n    # TODO: We need to do some processing of the labels since ALAMO is\r\n    # restrictive about the labels\r\n    # TODO: We need to think more carefully about \"input_bounds\".\r\n    # Alamo uses bounds during training, but we also want to consider\r\n    # \"valid\" bounds for the surrogate\r\n    def __init__(self, **settings):\r\n        super().__init__(**settings)\r\n\r\n        self._temp_context = None\r\n        self._almfile = None\r\n        self._trcfile = None\r\n\r\n        if self.config.alamo_path is not None:\r\n            alamo.executable = self.config.alamo_path\r\n\r\n        self._results = None\r\n\r\n    def train_surrogate(self):\r\n        \"\"\"\r\n        General workflow method for training an ALAMO surrogate.\r\n\r\n        Takes the existing data set and executes the ALAMO workflow to create\r\n        an AlamoSurrogate based on the current configuration arguments.\r\n\r\n        Args:\r\n            None\r\n\r\n        Returns:\r\n            tuple : (success, AlamoSurrogate, message) where success indicates\r\n            whether ALAMO was usccessfully executed, an instance of an\r\n            AlamoSurrogate representing the trained surrogate, and message is\r\n            the final status line from the ALAMO output log.\r\n        \"\"\"\r\n        # Get paths for temp files\r\n        self._get_files()\r\n\r\n        return_code = None\r\n        alamo_log = None\r\n        alamo_object = None\r\n\r\n        try:\r\n            # Write .alm file\r\n            self._write_alm_file()\r\n\r\n            # Call ALAMO executable\r\n            return_code, alamo_log = self._call_alamo()\r\n\r\n            # Read back results\r\n            trace_dict = self._read_trace_file(self._trcfile)\r\n\r\n            # Populate results and SurrogateModel object\r\n            self._populate_results(trace_dict)\r\n            alamo_object = self._build_surrogate_object()\r\n\r\n        finally:\r\n            # Clean up temporary files if required\r\n            self._remove_temp_files()\r\n\r\n        success = False\r\n        if return_code == 0:\r\n            # Non-zero return code implies an error\r\n            # specifics returned in the msg\r\n            success = True\r\n        alamo_msg = alamo_log.split(\"\\n\")[-3]\r\n\r\n        return success, alamo_object, alamo_msg\r\n\r\n    # TODO: let's generalize this under the metrics?\r\n    def get_alamo_results(self):\r\n        return self._results\r\n\r\n    def _get_files(self):\r\n        \"\"\"\r\n        Method to get/set paths for .alm and .trc files based on filename\r\n        configuration argument.\r\n\r\n        If filename is None, temporary files will be created.\r\n\r\n        Args:\r\n            None\r\n\r\n        Returns:\r\n            None\r\n        \"\"\"\r\n        if self._temp_context is None:\r\n            self._temp_context = TempfileManager.new_context()\r\n\r\n        if self.config.filename is None:\r\n            # Get a temporary file from the manager\r\n            almfile = self._temp_context.create_tempfile(suffix=\".alm\")\r\n        else:\r\n            almfile = self.config.filename\r\n\r\n            if not self.config.overwrite_files:\r\n                # It is OK if the trace file exists, as ALAMO will append to it\r\n                # The trace file reader handles this case\r\n                if os.path.isfile(almfile):\r\n                    raise FileExistsError(\r\n                        f\"A file with the name {almfile} already exists. \"\r\n                        f\"Either choose a new file name or set \"\r\n                        f\"overwrite_files = True.\"\r\n                    )\r\n\r\n            self._temp_context.add_tempfile(almfile, exists=False)\r\n\r\n        trcfile = os.path.splitext(almfile)[0] + \".trc\"\r\n        self._temp_context.add_tempfile(trcfile, exists=False)\r\n\r\n        if self.config.working_directory is None:\r\n            wrkdir = self._temp_context.create_tempdir()\r\n        else:\r\n            wrkdir = self.config.working_directory\r\n\r\n        # Set attributes to track file names\r\n        self._almfile = almfile\r\n        self._trcfile = trcfile\r\n        self._wrkdir = wrkdir\r\n\r\n    def _write_alm_to_stream(\r\n        self, stream, trace_fname=None, training_data=None, validation_data=None\r\n    ):\r\n        \"\"\"\r\n        Method to write an ALAMO input file (.alm) to a stream.\r\n        Users may provide specific data sets for training and validation.\r\n        If no data sets are provided, the data sets contained in the\r\n        AlamoModelTrainer are used.\r\n\r\n        Args:\r\n            stream: stream that data should be writen to\r\n            trace_fname: name for trace file (.trc) to be included in .alm file\r\n            training_data: Pandas dataframe to use for training surrogate\r\n            validation_data: Pandas dataframe to use for validating surrogate\r\n\r\n        Returns:\r\n            None\r\n        \"\"\"\r\n        if training_data is None:\r\n            training_data = self._training_dataframe\r\n        if validation_data is None:\r\n            validation_data = self._validation_dataframe\r\n\r\n        # Check bounds on inputs to avoid potential ALAMO failures\r\n        input_max = list()\r\n        input_min = list()\r\n        for k, b in self._input_bounds.items():\r\n            if b is None or b[0] is None or b[1] is None:\r\n                raise ConfigurationError(\r\n                    f\"ALAMO configuration error: invalid bounds on input {k} \" f\"({b}).\"\r\n                )\r\n            elif b[0] == b[1]:\r\n                raise ConfigurationError(\r\n                    f\"ALAMO configuration error: upper and lower bounds on \"\r\n                    f\"input {k} are equal.\"\r\n                )\r\n            elif b[1] < b[0]:\r\n                raise ConfigurationError(\r\n                    f\"ALAMO configuration error: upper bound is less than \"\r\n                    f\"lower bound for input {k}.\"\r\n                )\r\n            input_min.append(b[0])\r\n            input_max.append(b[1])\r\n\r\n        # Get number of data points to build alm file\r\n        n_rdata, n_inputs = training_data.shape\r\n\r\n        if validation_data is not None:\r\n            n_vdata, n_inputs = validation_data.shape\r\n        else:\r\n            n_vdata = 0\r\n\r\n        stream.write(\"# IDAES Alamopy input file\\n\")\r\n        stream.write(f\"NINPUTS {len(self._input_labels)}\\n\")\r\n        stream.write(f\"NOUTPUTS {len(self._output_labels)}\\n\")\r\n        stream.write(f\"XLABELS {' '.join(map(str, self._input_labels))}\\n\")\r\n        stream.write(f\"ZLABELS {' '.join(map(str, self._output_labels))}\\n\")\r\n        stream.write(f\"XMIN {' '.join(map(str, input_min))}\\n\")\r\n        stream.write(f\"XMAX {' '.join(map(str, input_max))}\\n\")\r\n        stream.write(f\"NDATA {n_rdata}\\n\")\r\n        if validation_data is not None:\r\n            stream.write(f\"NVALDATA {n_vdata}\\n\")\r\n        stream.write(\"\\n\")\r\n\r\n        # Other options for config\r\n        # Can be bool, list of floats, None, Enum, float\r\n        # Special cases\r\n        if self.config.monomialpower is not None:\r\n            stream.write(f\"MONO {len(self.config.monomialpower)}\\n\")\r\n        if self.config.multi2power is not None:\r\n            stream.write(f\"MULTI2 {len(self.config.multi2power)}\\n\")\r\n        if self.config.multi3power is not None:\r\n            stream.write(f\"MULTI3 {len(self.config.multi3power)}\\n\")\r\n        if self.config.ratiopower is not None:\r\n            stream.write(f\"RATIOS {len(self.config.ratiopower)}\\n\")\r\n        if self.config.custom_basis_functions is not None:\r\n            stream.write(f\"NCUSTOMBAS {len(self.config.custom_basis_functions)}\\n\")\r\n\r\n        for o in supported_options:\r\n            if self.config[o] is None:\r\n                # Write nothing to alm file\r\n                continue\r\n            elif isinstance(self.config[o], Enum):\r\n                # Need to write value of Enum\r\n                stream.write(f\"{o} {self.config[o].value}\\n\")\r\n            elif isinstance(self.config[o], bool):\r\n                # Cast bool to int\r\n                stream.write(f\"{o} {int(self.config[o])}\\n\")\r\n            elif isinstance(self.config[o], (str, float, int)):\r\n                # Write value to file\r\n                stream.write(f\"{o} {self.config[o]}\\n\")\r\n            else:\r\n                # Assume the argument is a list\r\n                stream.write(f\"{o} {' '.join(map(str, self.config[o]))}\\n\")\r\n\r\n        stream.write(\"\\nTRACE 1\\n\")\r\n        if trace_fname is not None:\r\n            stream.write(f\"TRACEFNAME {trace_fname}\\n\")\r\n\r\n        def _df_to_data_fragment(df, **kwargs):\r\n            text = df.to_string(\r\n                header=False,\r\n                index=False,\r\n                float_format=lambda x: str(x).format(\":g\"),\r\n                **kwargs,\r\n            )\r\n            return text\r\n\r\n        stream.write(\"\\nBEGIN_DATA\\n\")\r\n        # Columns will be writen in order in input and output lists\r\n        training_data_str = _df_to_data_fragment(\r\n            training_data,\r\n            columns=self._input_labels + self._output_labels,\r\n        )\r\n        stream.write(training_data_str)\r\n        stream.write(\"\\nEND_DATA\\n\")\r\n\r\n        if validation_data is not None:\r\n            # Add validation data defintion\r\n            stream.write(\"\\nBEGIN_VALDATA\\n\")\r\n            val_data_str = _df_to_data_fragment(\r\n                validation_data,\r\n                columns=self._input_labels + self._output_labels,\r\n            )\r\n            stream.write(val_data_str)\r\n            stream.write(\"\\nEND_VALDATA\\n\")\r\n\r\n        if self.config.custom_basis_functions is not None:\r\n            stream.write(\"\\nBEGIN_CUSTOMBAS\\n\")\r\n            for i in self.config.custom_basis_functions:\r\n                stream.write(f\"{str(i)}\\n\")\r\n            stream.write(\"END_CUSTOMBAS\\n\")\r\n\r\n    def _write_alm_file(self, training_data=None, validation_data=None):\r\n        \"\"\"\r\n        Method to write an ALAMO input file (.alm) using the current settings.\r\n        Users may provide specific data sets for training and validation.\r\n        If no data sets are provided, the data sets contained in the\r\n        AlamoModelTrainer are used.\r\n\r\n        Args:\r\n            training_data: Pandas dataframe to use for training surrogate\r\n            validation_data: Pandas dataframe to use for validating surrogate\r\n\r\n        Returns:\r\n            None\r\n        \"\"\"\r\n        f = open(self._almfile, \"w\")\r\n        self._write_alm_to_stream(f, self._trcfile, training_data, validation_data)\r\n        f.close()\r\n\r\n    def _call_alamo(self):\r\n        \"\"\"\r\n        Method to call ALAMO executable from Python, passing the current .alm\r\n        file as an argument.\r\n\r\n        Args:\r\n            None\r\n\r\n        Returns:\r\n            ALAMO: return code\r\n            log: string of the text output from ALAMO\r\n        \"\"\"\r\n        if alamo.executable is None:\r\n            raise FileNotFoundError(\r\n                \"Could not find ALAMO executable. Please ensure that ALAMO \"\r\n                \"is installed and in the system path, or provide a path to \"\r\n                \"the executable.\"\r\n            )\r\n\r\n        ostreams = [StringIO(), sys.stdout]\r\n\r\n        if self._temp_context is None:\r\n            self._get_files()\r\n\r\n        # Set working directory\r\n        cwd = os.getcwd()\r\n        os.chdir(self._wrkdir)\r\n\r\n        try:\r\n            # Add lst file to temp file manager\r\n            lstfname = os.path.splitext(os.path.basename(self._almfile))[0] + \".lst\"\r\n            lstpath = os.path.join(cwd, lstfname)\r\n            self._temp_context.add_tempfile(lstpath, exists=False)\r\n\r\n            with TeeStream(*ostreams) as t:\r\n                results = subprocess.run(\r\n                    [alamo.executable, str(self._almfile)],\r\n                    stdout=t.STDOUT,\r\n                    stderr=t.STDERR,\r\n                    universal_newlines=True,\r\n                )\r\n\r\n                t.STDOUT.flush()\r\n                t.STDERR.flush()\r\n\r\n            return_code = results.returncode\r\n            alamo_log = ostreams[0].getvalue()\r\n\r\n        except OSError:\r\n            _log.error(\r\n                f\"Could not execute the command: alamo {str(self._almfile)}. \",\r\n                f\"Error message: {sys.exc_info()[1]}.\",\r\n            )\r\n            raise\r\n\r\n        finally:\r\n            # Revert cwd to where it started\r\n            os.chdir(cwd)\r\n\r\n        if \"ALAMO terminated with termination code \" in alamo_log:\r\n            self._remove_temp_files()\r\n            _log.warn(\r\n                \"ALAMO executable returned non-zero return code. Check \"\r\n                \"the ALAMO output for more information.\"\r\n            )\r\n\r\n        return return_code, alamo_log\r\n\r\n    def _read_trace_file(self, trcfile, has_validation_data=False):\r\n        \"\"\"\r\n        Method to read the results of an ALAMO run from a trace (.trc) file.\r\n        The name location of the trace file is tored on the AlamoModelTrainer\r\n        object and is generally set automatically.\r\n\r\n        Args:\r\n            trcfile : str\r\n               Path to the trcfile to read\r\n            output_labels : list of str\r\n               List of strings of the output_labels (in order)\r\n            has_validation_data : bool\r\n                Bool indicating whether valdiation data was included in ALAMO run\r\n\r\n        Returns:\r\n            trace_dict: contents of trace file as a dict\r\n        \"\"\"\r\n        with open(trcfile, \"r\") as f:\r\n            lines = f.readlines()\r\n        f.close()\r\n\r\n        output_labels = self.output_labels()\r\n\r\n        trace_read = {}\r\n        # Get headers from first line in trace file\r\n        headers = lines[0].split(\", \")\r\n        for i in range(len(headers)):\r\n            header = headers[i].strip(\"#\\n\")\r\n            if header in common_trace:\r\n                trace_read[header] = None\r\n            else:\r\n                trace_read[header] = {}\r\n\r\n        # Get trace output from final line(s) of file\r\n        # ALAMO will append new lines to existing trace files\r\n        # For multiple outputs, each output has its own line in trace file\r\n        if self._validation_dataframe is not None or has_validation_data:\r\n            omult = 2\r\n        else:\r\n            omult = 1\r\n\r\n        for j in range(len(output_labels)):\r\n            trace = lines[(-len(output_labels) + j) * omult].split(\", \")\r\n\r\n            for i in range(len(headers)):\r\n                header = headers[i].strip(\"#\\n\")\r\n                trace_val = trace[i].strip(\"\\n\")\r\n\r\n                # Replace Fortran powers (^) with Python powers (**)\r\n                trace_val = trace_val.replace(\"^\", \"**\")\r\n                # Replace = with ==\r\n                trace_val = trace_val.replace(\"=\", \"==\")\r\n\r\n                if header in common_trace:\r\n                    # These should be common across all output\r\n                    if trace_read[header] is None:\r\n                        # No value yet, so set value\r\n                        trace_read[header] = trace_val\r\n                    else:\r\n                        # Check that current value matches the existng value\r\n                        if trace_read[header] != trace_val:\r\n                            raise RuntimeError(\r\n                                f\"Mismatch in values when reading ALAMO trace \"\r\n                                f\"file. Values for {header}: \"\r\n                                f\"{trace_read[header]}, {header}\"\r\n                            )\r\n                else:\r\n                    trace_read[header][output_labels[j]] = trace_val\r\n\r\n                # Do some final sanity checks\r\n                if header == \"OUTPUT\":\r\n                    # OUTPUT should be equal to the current index of outputs\r\n                    if trace_val != str(j + 1):\r\n                        raise RuntimeError(\r\n                            f\"Mismatch when reading ALAMO trace file. \"\r\n                            f\"Expected OUTPUT = {j+1}, found {trace_val}.\"\r\n                        )\r\n                elif header == \"SET\":\r\n                    # SET should always be 0 - higher numbers are for\r\n                    # validation data sets\r\n                    if trace_val != \"0\":\r\n                        raise RuntimeError(\r\n                            f\"Mismatch when reading ALAMO trace file. \"\r\n                            f\"Expected SET = 0, found {trace_val}. \"\r\n                            f\"This likely indicates the presence of \"\r\n                            f\"unexpected validation data sets.\"\r\n                        )\r\n                elif header == \"Model\":\r\n                    # Var label on LHS should match output label\r\n                    vlabel = trace_val.split(\"==\")[0].strip()\r\n                    if vlabel != output_labels[j]:\r\n                        raise RuntimeError(\r\n                            f\"Mismatch when reading ALAMO trace file. \"\r\n                            f\"Label of output variable in expression \"\r\n                            f\"({vlabel}) does not match expected label \"\r\n                            f\"({output_labels[j]}).\"\r\n                        )\r\n\r\n        return trace_read\r\n\r\n    def _populate_results(self, trace_dict):\r\n        \"\"\"\r\n        Method to populate the results object with data from a trace file.\r\n\r\n        Args:\r\n            trace_dict: trace file data in form of a dict\r\n\r\n        Returns:\r\n            None\r\n        \"\"\"\r\n        self._results = trace_dict\r\n\r\n    def _build_surrogate_object(self):\r\n        \"\"\"\r\n        Method to construct an AlmaoObject from the current results\r\n        object.\r\n\r\n        Args:\r\n            None\r\n\r\n        Returns:\r\n            AlamoSurrogate\r\n        \"\"\"\r\n        return AlamoSurrogate(\r\n            surrogate_expressions=self._results[\"Model\"],\r\n            input_labels=self._input_labels,\r\n            output_labels=self._output_labels,\r\n            input_bounds=self._input_bounds,\r\n        )\r\n\r\n    def _remove_temp_files(self):\r\n        \"\"\"\r\n        Method to remove temporary files created during the ALAMO workflow,\r\n        i.e. the .alm and .trc files.\r\n\r\n        Args:\r\n            None\r\n\r\n        Returns:\r\n            None\r\n        \"\"\"\r\n        remove = True\r\n        if self.config.filename is not None:\r\n            remove = False\r\n\r\n        self._temp_context.release(remove=remove)\r\n        # Release tempfile context\r\n        self._temp_context = None\r\n\r\n\r\nclass AlamoSurrogate(SurrogateBase):\r\n    \"\"\"\r\n    Standard SurrogateObject for surrogates trained using ALAMO.\r\n\r\n    Contains methods to both populate a Pyomo Block with constraints\r\n    representing the surrogate and to evaluate the surrogate a set of user\r\n    provided points.\r\n    \"\"\"\r\n\r\n    def __init__(\r\n        self, surrogate_expressions, input_labels, output_labels, input_bounds=None\r\n    ):\r\n        super().__init__(input_labels, output_labels, input_bounds)\r\n        self._surrogate_expressions = surrogate_expressions\r\n        self._fcn = None\r\n\r\n    def evaluate_surrogate(self, inputs):\r\n        \"\"\"\r\n        Method to method to evaluate the ALAMO surrogate model at a set of user\r\n        provided values.\r\n\r\n        Args:\r\n           dataframe: pandas DataFrame\r\n              The dataframe of input values to be used in the evaluation. The dataframe\r\n              needs to contain a column corresponding to each of the input labels. Additional\r\n              columns are fine, but are not used.\r\n\r\n        Returns:\r\n            output: pandas Dataframe\r\n              Returns a dataframe of the the output values evaluated at the provided inputs.\r\n              The index of the output dataframe should match the index of the provided inputs.\r\n        \"\"\"\r\n        # Create a set of lambda functions for evaluating the surrogate.\r\n        if self._fcn is None:\r\n            fcn = dict()\r\n            for o in self._output_labels:\r\n                fcn[o] = eval(\r\n                    f\"lambda {', '.join(self._input_labels)}: \"\r\n                    f\"{self._surrogate_expressions[o].split('==')[1]}\",\r\n                    GLOBAL_FUNCS,\r\n                )\r\n            self._fcn = fcn\r\n\r\n        # Use numpy to do the calculations as it is faster\r\n        inputdata = inputs[self._input_labels].to_numpy()\r\n        outputs = np.zeros(shape=(inputs.shape[0], len(self._output_labels)))\r\n\r\n        for i in range(inputdata.shape[0]):\r\n            for o in range(len(self._output_labels)):\r\n                o_name = self._output_labels[o]\r\n                outputs[i, o] = value(self._fcn[o_name](*inputdata[i, :]))\r\n\r\n        return pd.DataFrame(\r\n            data=outputs, index=inputs.index, columns=self._output_labels\r\n        )\r\n\r\n    def populate_block(self, block, additional_options=None):\r\n        \"\"\"\r\n        Method to populate a Pyomo Block with surrogate model constraints.\r\n\r\n        Args:\r\n            block: Pyomo Block component to be populated with constraints.\r\n            additional_options: None\r\n               No additional options are required for this surrogate object\r\n        Returns:\r\n            None\r\n        \"\"\"\r\n\r\n        # TODO: do we need to add the index_set stuff back in?\r\n        output_set = Set(initialize=self._output_labels, ordered=True)\r\n\r\n        def alamo_rule(b, o):\r\n            lvars = block.input_vars_as_dict()\r\n            lvars.update(block.output_vars_as_dict())\r\n            return eval(self._surrogate_expressions[o], GLOBAL_FUNCS, lvars)\r\n\r\n        block.alamo_constraint = Constraint(output_set, rule=alamo_rule)\r\n\r\n    def save(self, strm):\r\n        \"\"\"\r\n        Save an instance of this surrogate to the strm so the model can be used later.\r\n\r\n        Args:\r\n           strm: IO.TextIO\r\n              This is the python stream like a file object or StringIO that will be used\r\n              to serialize the surrogate object. This method writes a string\r\n              of json data to the stream.\r\n        \"\"\"\r\n        json.dump(\r\n            {\r\n                \"surrogate\": self._surrogate_expressions,\r\n                \"input_labels\": self._input_labels,\r\n                \"output_labels\": self._output_labels,\r\n                \"input_bounds\": self._input_bounds,\r\n            },\r\n            strm,\r\n        )\r\n\r\n    @classmethod\r\n    def load(cls, strm):\r\n        \"\"\"\r\n        Create an instance of a surrogate from a stream.\r\n\r\n        Args:\r\n           strm: stream\r\n              This is the python stream containing the data required to load the surrogate.\r\n              This is often, but does not need to be a string of json data.\r\n\r\n        Returns: an instance of the derived class or None if it failed to load\r\n        \"\"\"\r\n        d = json.load(strm)\r\n\r\n        surrogate_expressions = d[\"surrogate\"]\r\n        input_labels = d[\"input_labels\"]\r\n        output_labels = d[\"output_labels\"]\r\n\r\n        # Need to convert list of bounds to tuples\r\n        input_bounds = {}\r\n        for k, v in d[\"input_bounds\"].items():\r\n            input_bounds[k] = tuple(v)\r\n\r\n        return AlamoSurrogate(\r\n            surrogate_expressions=surrogate_expressions,\r\n            input_labels=input_labels,\r\n            output_labels=output_labels,\r\n            input_bounds=input_bounds,\r\n        )\r\n", "meta": {"hexsha": "6aa48509f0379589d10a5722d4be3edb07c0755e", "size": 44834, "ext": "py", "lang": "Python", "max_stars_repo_path": "idaes/core/surrogate/alamopy.py", "max_stars_repo_name": "OOAmusat/idaes-pse", "max_stars_repo_head_hexsha": "ae7d3bb8e372bc32822dcdcb75e9fd96b78da539", "max_stars_repo_licenses": ["RSA-MD"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "idaes/core/surrogate/alamopy.py", "max_issues_repo_name": "OOAmusat/idaes-pse", "max_issues_repo_head_hexsha": "ae7d3bb8e372bc32822dcdcb75e9fd96b78da539", "max_issues_repo_licenses": ["RSA-MD"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "idaes/core/surrogate/alamopy.py", "max_forks_repo_name": "OOAmusat/idaes-pse", "max_forks_repo_head_hexsha": "ae7d3bb8e372bc32822dcdcb75e9fd96b78da539", "max_forks_repo_licenses": ["RSA-MD"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.4418972332, "max_line_length": 95, "alphanum_fraction": 0.5559619931, "include": true, "reason": "import numpy,from pyomo", "num_tokens": 9207, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4493926344647597, "lm_q2_score": 0.1143685246724982, "lm_q1q2_score": 0.05139637260242183}}
{"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"Provide a wrapper around quadratic programming solvers.\n\nReferences:\n    [1] https://github.com/stephane-caron/qpsolvers\n\"\"\"\n\nimport numpy as np\n\n# CVXOPT\n# import cvxopt\n# CVXPY: nice wrapper around cvxopt\n# import cvxpy\n# Quadprog\n# import quadprog\n\n# QPsolvers optimizers: unified Python interface for multiple QP solvers (cvxopt, cvxpy, quadprog,...)\ntry:\n    import qpsolvers\nexcept ImportError as e:\n    raise ImportError(e.__str__() + \"\\n HINT: you can install qpsolvers directly via 'pip install qpsolvers'.\")\n\nfrom pyrobolearn.optimizers import Optimizer\n\n\n__author__ = \"Brian Delhaisse\"\n__copyright__ = \"Copyright 2018, PyRoboLearn\"\n__credits__ = [\"Brian Delhaisse\"]\n__license__ = \"GNU GPLv3\"\n__version__ = \"1.0.0\"\n__maintainer__ = \"Brian Delhaisse\"\n__email__ = \"briandelhaisse@gmail.com\"\n__status__ = \"Development\"\n\n\n# class CVXOPT(Optimizer):\n#     r\"\"\"Convex Optimizer\n#\n#     Note: cvxpy module is a nice wrapper around cvxopt that follows paradigm of a disciplined convex programming.\n#\n#     References:\n#         [1] Python Software for Convex Optimization: https://cvxopt.org/\n#         [2] Github repo: https://github.com/cvxopt/cvxopt\n#     \"\"\"\n#     pass\n#\n#\n# class CVXPY(Optimizer):\n#     r\"\"\"Convex Optimizer\n#\n#     References:\n#         [1] CVXPY: http://www.cvxpy.org/\n#         [2] Github repo: https://github.com/cvxgrp/cvxpy\n#     \"\"\"\n#     pass\n#\n#\n# class QuadProg(object):\n#     r\"\"\"Quadprog\n#\n#     References:\n#         [1] Github repo: https://github.com/rmcgibbo/quadprog\n#     \"\"\"\n#     pass\n\nclass QP(Optimizer):\n    r\"\"\"Quadratic Programming solvers\n\n    This class uses the `qpsolvers` which is a unified Python interface for multiple QP solvers [1,2].\n\n    .. math::\n\n        \\min_{x \\in R^n} \\frac{1}{2} x^T P x + q^T x\n\n    subject to\n\n    .. math::\n\n        Gx \\leq h\n        Ax = b\n\n    where :math:`x` is the vector of optimization variables, the matrix :math:`P` and vector :math:`q` are used to\n    define any quadratic objective function on these variables, while the matrix-vector couples :math:`(G,h)` and\n    :math:`(A,b)` respectively define inequality and equality constraints. Vector inequalities apply coordinate by\n    coordinate [1].\n\n    - Dense solvers:\n        - CVXOPT\n        - CVXPY\n        - qpOASES\n        - quadprog\n    - Sparse solvers:\n        - ECOS as wrapped by CVXPY\n        - Gurobi\n        - MOSEK\n        - OSQP\n\n    Check the available solvers by calling `print(qpsolvers.available_solvers)`.\n\n    Notes: Many solvers (including CVXOPT, OSQP and quadprog) assume that `P` is a symmetric matrix, and may return\n    erroneous results when that is not the case. You can set ``sym_proj=True`` to project `P` on its symmetric part,\n    at the cost of some computation time.\n\n    References:\n        [1] QP in Python: https://scaron.info/blog/quadratic-programming-in-python.html\n        [2] Github repo: https://github.com/stephane-caron/qpsolvers\n    \"\"\"\n\n    def __init__(self, method='quadprog', *args, **kwargs):\n        \"\"\"\n        Initialize the QP solver.\n\n        Args:\n            method (str): QP method/library to use. Select between ['cvxopt', 'cvxpy', 'ecos', 'gurobi', 'mosek',\n                'osqp', 'qpoases', 'quadprog']\n        \"\"\"\n        super(QP, self).__init__(*args, **kwargs)\n\n        solvers = set(qpsolvers.available_solvers)\n        if len(solvers) == 0:\n            raise ValueError(\"No QP solvers have been found on this computer. Please install one of the QP modules\")\n        if method not in solvers:\n            method = 'quadprog'\n        self.method = method\n\n        # check methods that require a symmetric matrix for P\n        methods = ['cvxopt', 'osqp', 'quadprog']\n        self.sym_proj = True if self.method in set(methods) else False\n\n    ##################\n    # Static Methods #\n    ##################\n\n    @staticmethod\n    def is_symmetric(X, tol=1e-8):\n        \"\"\"Check if the given matrix is symmetric.\"\"\"\n        return np.allclose(X, X.T, atol=tol)\n\n    ###########\n    # Methods #\n    ###########\n\n    def optimize(self, Q, p, x0=None, G=None, h=None, A=None, b=None):\n        r\"\"\"\n        Optimize the given quadratic problem.\n\n        .. math::\n\n            \\min_{x \\in \\mathbb{R}^N} \\frac{1}{2} x^T Q x + p^T x\n\n        subject to\n\n        .. math::\n\n            Gx \\leq h\n            Ax = b\n\n        Args:\n            Q (np.array[N,N]): matrix used in the QP objective function where `N` is the size of the vector `x` being\n                optimized.\n            p (np.array[N]): vector used in the QP objective function where `N` is the size of the vector `x` being\n                optimized.\n            G (np.array[M,N]): matrix used in the inequality constraint, where `M` is the number of inequalities, and\n                `N` is the size of the vector `x` being optimized. Note that if you have lower and upper bounds for\n                the vector `x`, you can set :attr:`G` to be the concatenation of :math:`[-I, I]^\\top`, where :math:`I`\n                is the identity matrix.\n            h (np.array[M]): vector used in the inequality constraint, where `M` is the number of inequalities. Note\n                that if you have lower and upper bounds for the vector `x`, you can set :attr:`h` to be the\n                concatenation of :math:`[-b_l^\\top, b_u^\\top]`, where :math:`b_l` and :math:`b_u` are the lower and\n                upper bounds respectively.\n            A (np.array[K,N]): matrix used in the equality constraint.\n            b (np.array[K,N]): vector used in the equality constraint.\n\n        Returns:\n            np.array: QP solution\n        \"\"\"\n        return qpsolvers.solve_qp(Q, p, G, h, A, b, solver=self.method, initvals=x0, sym_proj=self.sym_proj)\n", "meta": {"hexsha": "cd9a851fd554d1772713c9c13bd9e50ba9d1092a", "size": 5766, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyrobolearn/optimizers/qpsolvers_optimizer.py", "max_stars_repo_name": "Pandinosaurus/pyrobolearn", "max_stars_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-01-21T21:08:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T16:45:49.000Z", "max_issues_repo_path": "pyrobolearn/optimizers/qpsolvers_optimizer.py", "max_issues_repo_name": "Pandinosaurus/pyrobolearn", "max_issues_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pyrobolearn/optimizers/qpsolvers_optimizer.py", "max_forks_repo_name": "Pandinosaurus/pyrobolearn", "max_forks_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-29T21:25:39.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-29T21:25:39.000Z", "avg_line_length": 32.2122905028, "max_line_length": 118, "alphanum_fraction": 0.6123829344, "include": true, "reason": "import numpy,import cvxpy", "num_tokens": 1557, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4610167941228965, "lm_q2_score": 0.111241213873679, "lm_q1q2_score": 0.051284067794382965}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# <!-- HTML file automatically generated from DocOnce source (https://github.com/doconce/doconce/)\n# doconce format html hw1.do.txt --no_mako -->\n# <!-- dom:TITLE: PHY321: Classical Mechanics 1 -->\n\n# # PHY321: Classical Mechanics 1\n# **Homework 1, due January 21 (midnight)**\n# \n# Date: **Jan 11, 2022**\n\n# ### Practicalities about  homeworks and projects\n# \n# 1. You can work in groups (optimal groups are often 2-3 people) or by yourself. If you work as a group you can hand in one answer only if you wish. **Remember to write your name(s)**!\n# \n# 2. Homeworks (final version) are available approximately ten days before the  deadline. \n# \n# 3. How do I(we)  hand in?  You can hand in the paper and pencil exercises as a scanned document. For this homework this applies to exercises 1-5. You should upload the scan to D2L. Alternatively, you can hand in everyhting (if you are ok with typing mathematical formulae using say Latex) as a jupyter notebook at D2L. The numerical exercise (exercise 6 here) should always be handed in as a jupyter notebook by the deadline at D2L.\n\n# ### Exercise 1 (12 pt), math reminder, properties of exponential function\n# \n# The first exercise is meant to remind ourselves about properties of\n# the exponential function and imaginary numbers. This is highly\n# relevant later in this course when we start analyzing oscillatory\n# motion and some wave mechanics. As physicists we should thus feel comfortable with expressions that\n# include $\\exp{(\\imath\\omega t)}$. Here $t$ could be interpreted as time and $\\omega$ as a frequency and $\\imath$ is the imaginary unit number.\n# \n# * 1a (3pt): Perform Taylor expansions in powers of $\\omega t$ of the functions $\\cos{(\\omega t)}$ and $\\sin{(\\omega t)}$.\n# \n# * 1b (3pt): Perform a Taylor expansion of $\\exp{(i\\omega t)}$.\n# \n# * 1c (3pt): Using parts (a) and (b) here, show that $\\exp{(\\imath\\omega t)}=\\cos{(\\omega t)}+\\imath\\sin{(\\omega t)}$.\n# \n# * 1d (3pt): Show that $\\ln{(−1)} = \\imath\\pi$.\n\n# ### Exercise 2 (12 pt), Vector algebra\n# \n# * 2a (6pt) One of the many uses of the scalar product is to find the angle between two given vectors. Find the angle between the vectors $\\boldsymbol{a}=(1,2,4)$ and $\\boldsymbol{b}=(4,2,1)$ by evaluating their scalar product.\n# \n# * 2b (6pt) For a cube with sides of length 1, one vertex at the origin, and sides along the $x$, $y$, and $z$ axes, the vector of the body diagonal from the origin can be written $\\boldsymbol{a}=(1, 1, 1)$ and the vector of the face diagonal in the $xy$ plane from the origin is $\\boldsymbol{b}=(1,1,0)$. Find first the lengths of the body diagonal and the face diagonal. Use then part (2a) to find the angle between the body diagonal and the face diagonal.\n\n# ### Exercise 3 (10 pt), More vector mathematics\n# \n# * 3a (5pt) Show (using the fact that multiplication of reals is distributive) that $\\boldsymbol{a}(\\boldsymbol{b}+\\boldsymbol{c})=\\boldsymbol{a}\\boldsymbol{b}+\\boldsymbol{a}\\boldsymbol{c}$.\n# \n# * 3b (5pt) Show that (using product rule for differentiating reals)  $\\frac{d}{dt}(\\boldsymbol{a}\\boldsymbol{b})=\\boldsymbol{a}\\frac{d\\boldsymbol{b}}{dt}+\\boldsymbol{b}\\frac{d\\boldsymbol{a}}{dt}$\n\n# ### Exercise 4 (10 pt), Algebra of cross products\n# \n# * 4a (5pt) Show that the cross products are distribuitive $\\boldsymbol{a}\\times(\\boldsymbol{b}+\\boldsymbol{c})=\\boldsymbol{a}\\times\\boldsymbol{b}+\\boldsymbol{a}\\times\\boldsymbol{c}$.\n# \n# * 4b (5pt) Show that $\\frac{d}{dt}(\\boldsymbol{a}\\times\\boldsymbol{b})=\\boldsymbol{a}\\times\\frac{d\\boldsymbol{b}}{dt}+\\frac{d\\boldsymbol{a}}{dt}\\times \\boldsymbol{b}$. Be careful with the order of factors\n\n# ### Exercise 5 (10 pt), Area of triangle and law of sines\n# \n# Exercise 1.18 in the textbook of Taylor, Classical Mechanics. Part (1.18a) gives 5pt and part (1.18b) gives also 5pt.\n\n# ### Exercise 6 (40pt), Numerical elements, getting started with some simple data\n# \n# **This exercise should be handed in as a jupyter-notebook** at D2L. Remember to write your name(s). \n# \n# Our first numerical attempt will involve reading data from file or\n# just setting up two vectors, one for position and one for time. Our data are from \n# [Usain Bolt's world record 100m during the olympic games in Beijing in\n# 2008](https://www.youtube.com/watch?v=93dC0o2aHto). The data show the time used in units of 10m (see below). Before we however\n# venture into this, we need to repeat some basic Python syntax with an\n# emphasis on\n# \n# * basic Python syntax for arrays\n# \n# * define and operate on vectors and matrices in Python\n# \n# * create plots for motion in 1D space\n# \n# For more information, see the [introductory slides](https://mhjensen.github.io/Physics321/doc/pub/week2/html/week2.html).\n# Here are some of the basic packages we will be using this week\n\n# In[1]:\n\n\nget_ipython().run_line_magic('matplotlib', 'inline')\n\nimport numpy as np \nimport matplotlib.pyplot as plt\nget_ipython().run_line_magic('matplotlib', 'inline')\n\n\n# The first exercise here deals with simply getting familiar with vectors and matrices.\n# \n# We will be working with vectors and matrices to get you familiar with them\n# \n# 1. Initalize two three-dimensional $xyz$ vectors in the below cell using np.array([x,y,z]). Vectors are represented through arrays in python\n# \n# 2. V1 should have x1=1, y1 =2, and z1=3. \n# \n# 3. Vector 2 should have x2=4, y2=5,  and z2=6. \n# \n# 4. Print both vectors to make sure your code is working properly.\n\n# In[2]:\n\n\nV1 = np.array([1,2,3])\nV2 = np.array([4,5,6])\nprint(\"V1: \", V1)\nprint(\"V2: \", V2)\n\n\n# If this is not too familiar, here's a useful link for creating vectors in python\n# <https://docs.scipy.org/doc/numpy-1.13.0/user/basics.creation.html>. Alternatively, look up the [introductory slides](https://mhjensen.github.io/Physics321/doc/pub/week2/html/week2.html).\n# \n# Now lets do some basic mathematics with vectors.\n# \n# Compute and print the following, and double check with hand calculations:\n# \n# * 6a (2pt)  Calculate $\\boldsymbol{V}_1-\\boldsymbol{V}_2$.\n# \n# * 6b (2pt)  Calculate $\\boldsymbol{V}_2-\\boldsymbol{V}_1$.\n# \n# * 6c (2pt) Calculate the dot product $\\boldsymbol{V}_1\\boldsymbol{V}_2$.\n# \n# * 6d (2pt) Calculate the cross product $\\boldsymbol{V}_1\\times\\boldsymbol{V}_2$.\n# \n# Here is some useful explanation on numpy array operations if you feel a bit confused by what is happening,\n# see <https://www.pluralsight.com/guides/overview-basic-numpy-operations>.\n# \n# The following code prints the first two exercises\n\n# In[3]:\n\n\nprint(V1-V2)\nprint(V2-V1)\n\n\n# For the dot product of V1 and V2 below we can use the **dot** function of **numpy** as follows\n\n# In[4]:\n\n\nprint(V1.dot(V2))\n\n\n# As a small challenge try to write your own function for the **dot** product of two vectors.\n# \n# Matrices can be created in a similar fashion in python.  In this\n# language we can work with them through the package numpy (which we\n# have already imported)\n\n# In[5]:\n\n\nM1 = np.matrix([[1,2,3],\n             [4,5,6],\n             [7,8,9]])\nM2 = np.matrix([[1,2],\n             [3,4],\n             [5,6]])\nM3 = np.matrix([[9,8,7],\n             [4,5,6],\n             [7,6,9]])\n\n\n# Matrices can be added in the same way vectors are added in python as shown here\n\n# In[6]:\n\n\nprint(\"M1+M3: \", M1+M3)\n\n\n# What happens if we try to do $M1+M2$?\n# \n# That's enough vectors and matrices for now. Let's move on to some physics problems! Yes, the actual subject we are studying for. \n# \n# We can opt for two different ways of handling the data. The data is listed in the table here and represents the total time Usain Bolt used in steps of  10 meters of distance. The label $i$ is just a counter and we start from zero since Python arrays are by default set from zero. The variable $t$ is time in seconds and $x$ is the position in meters.\n# \n# <table class=\"dotable\" border=\"1\">\n# <thead>\n# <tr><th align=\"center\"> i  </th> <th align=\"center\"> 0  </th> <th align=\"center\"> 1  </th> <th align=\"center\"> 2  </th> <th align=\"center\"> 3  </th> <th align=\"center\"> 4  </th> <th align=\"center\"> 5  </th> <th align=\"center\"> 6  </th> <th align=\"center\"> 7  </th> <th align=\"center\"> 8  </th> <th align=\"center\"> 9  </th> </tr>\n# </thead>\n# <tbody>\n# <tr><td align=\"center\">   x[m]    </td> <td align=\"center\">   10      </td> <td align=\"center\">   20      </td> <td align=\"center\">   30      </td> <td align=\"center\">   40      </td> <td align=\"center\">   50      </td> <td align=\"center\">   60      </td> <td align=\"center\">   70      </td> <td align=\"center\">   80      </td> <td align=\"center\">   90      </td> <td align=\"center\">   100     </td> </tr>\n# <tr><td align=\"center\">   t[s]    </td> <td align=\"center\">   1.85    </td> <td align=\"center\">   2.87    </td> <td align=\"center\">   3.78    </td> <td align=\"center\">   4.65    </td> <td align=\"center\">   5.50    </td> <td align=\"center\">   6.32    </td> <td align=\"center\">   7.14    </td> <td align=\"center\">   7.96    </td> <td align=\"center\">   8.79    </td> <td align=\"center\">   9.69    </td> </tr>\n# </tbody>\n# </table>\n# \n# * 6e (6pt) You can here make a file with the above data and read them in and set up two vectors, one for time and one for position. Alternatively, you can just set up these two vectors directly and define two vectors in your Python code.\n# \n# The following example code may help here\n\n# In[7]:\n\n\n# we just initialize time and position\nx = np.array([10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0])\nt = np.array([1.85, 2.87, 3.78, 4.65, 5.50, 6.32, 7.14, 7.96, 8.79, 9.69])\nplt.plot(t,x, color='black')\nplt.xlabel(\"Time t[s]\")\nplt.ylabel(\"Position x[m]\")\nplt.title(\"Usain Bolt's world record run\")\nplt.show()\n\n\n# * 6f (6pt) Plot the position as function of time\n# \n# * 6g (10pt) Compute thereafter the mean velocity for every interval $i$ and the total velocity (from $i=0$ to the given interval $i$) for each interval and plot these two quantities as function of time. Comment your results.\n# \n# * 6h (10pt) Finally, compute and plot the mean acceleration for each interval and the total acceleration. Again, comment your results. Can you see whether he slowed down during the last meters?\n", "meta": {"hexsha": "e9240c5e5f73edab16672cdd0af0c5ce0e11e9f3", "size": 10143, "ext": "py", "lang": "Python", "max_stars_repo_path": "doc/LectureNotes/_build/jupyter_execute/hw1.py", "max_stars_repo_name": "Shield94/Physics321", "max_stars_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "doc/LectureNotes/_build/jupyter_execute/hw1.py", "max_issues_repo_name": "Shield94/Physics321", "max_issues_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "doc/LectureNotes/_build/jupyter_execute/hw1.py", "max_forks_repo_name": "Shield94/Physics321", "max_forks_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 48.0710900474, "max_line_length": 459, "alphanum_fraction": 0.6798777482, "include": true, "reason": "import numpy", "num_tokens": 3143, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.20181321265898594, "lm_q2_score": 0.2538610126142736, "lm_q1q2_score": 0.05123250652454991}}
{"text": "\"\"\"Tools for setting up interactive sessions. \"\"\"\n\nfrom sympy.interactive.printing import init_printing\n\npreexec_source = \"\"\"\\\nfrom __future__ import division\nfrom sympy import *\nx, y, z, t = symbols('x y z t')\nk, m, n = symbols('k m n', integer=True)\nf, g, h = symbols('f g h', cls=Function)\n\"\"\"\n\nverbose_message = \"\"\"\\\nThese commands were executed:\n%(source)s\nDocumentation can be found at http://www.sympy.org\n\"\"\"\n\nno_ipython = \"\"\"\\\nCouldn't locate IPython. Having IPython installed is greatly recommended.\nSee http://ipython.scipy.org for more details. If you use Debian/Ubuntu,\njust install the 'ipython' package and start isympy again.\n\"\"\"\n\ndef _make_message(ipython=True, quiet=False, source=None):\n    \"\"\"Create a banner for an interactive session. \"\"\"\n    from sympy import __version__ as sympy_version\n    from sympy.polys.domains import GROUND_TYPES\n    from sympy.utilities.misc import ARCH\n    from sympy import SYMPY_DEBUG\n\n    import sys\n    import os\n\n    python_version = \"%d.%d.%d\" % sys.version_info[:3]\n\n    if ipython:\n        shell_name = \"IPython\"\n    else:\n        shell_name = \"Python\"\n\n    info = ['ground types: %s' % GROUND_TYPES]\n\n    cache = os.getenv('SYMPY_USE_CACHE')\n\n    if cache is not None and cache.lower() == 'no':\n        info.append('cache: off')\n\n    if SYMPY_DEBUG:\n        info.append('debugging: on')\n\n    args = shell_name, sympy_version, python_version, ARCH, ', '.join(info)\n    message = \"%s console for SymPy %s (Python %s-%s) (%s)\\n\" % args\n\n    if not quiet:\n        if source is None:\n            source = preexec_source\n\n        _source = \"\"\n\n        for line in source.split('\\n')[:-1]:\n            if not line:\n                _source += '\\n'\n            else:\n                _source += '>>> ' + line + '\\n'\n\n        message += '\\n' + verbose_message % {'source': _source}\n\n    return message\n\ndef int_to_Integer(s):\n    \"\"\"\n    Wrap integer literals with Integer.\n\n    This is based on the decistmt example from\n    http://docs.python.org/library/tokenize.html.\n\n    Only integer literals are converted.  Float literals are left alone.\n    Example\n    =======\n\n    >>> from sympy.interactive.session import int_to_Integer\n    >>> from sympy import Integer\n    >>> s = '1.2 + 1/2 - 0x12 + a1'\n    >>> int_to_Integer(s)\n    '1.2 +Integer (1 )/Integer (2 )-Integer (0x12 )+a1 '\n    >>> s = 'print (1/2)'\n    >>> int_to_Integer(s)\n    'print (Integer (1 )/Integer (2 ))'\n    >>> exec(s) #doctest: +SKIP\n    0.5\n    >>> exec(int_to_Integer(s))\n    1/2\n    \"\"\"\n    from tokenize import generate_tokens, untokenize, NUMBER, NAME, OP\n    from StringIO import StringIO\n\n    def _is_int(num):\n        \"\"\"\n        Returns true if string value num (with token NUMBER) represents an integer.\n        \"\"\"\n        # XXX: Is there something in the standard library that will do this?\n        if '.' in num or 'j' in num.lower() or 'e' in num.lower():\n            return False\n        return True\n\n    result = []\n    g = generate_tokens(StringIO(s).readline)   # tokenize the string\n    for toknum, tokval, _, _, _  in g:\n        if toknum == NUMBER and _is_int(tokval):  # replace NUMBER tokens\n            result.extend([\n                (NAME, 'Integer'),\n                (OP, '('),\n                (NUMBER, tokval),\n                (OP, ')')\n            ])\n        else:\n            result.append((toknum, tokval))\n    return untokenize(result)\n\n# XXX: Something like this might be used, but it only works on single line\n# inputs.  See\n# http://mail.scipy.org/pipermail/ipython-user/2012-August/010846.html and\n# https://github.com/ipython/ipython/issues/1491.  So instead we are forced to\n# just monkey-patch run_cell until IPython builds a better API.\n#\n# class IntTransformer(object):\n#     \"\"\"\n#     IPython command line transformer that recognizes and replaces int\n#     literals.\n#\n#     Based on\n#     https://bitbucket.org/birkenfeld/ipython-physics/src/71b2d850da00/physics.py.\n#\n#     \"\"\"\n#     priority = 99\n#     enabled = True\n#     def transform(self, line, continue_prompt):\n#         import re\n#         from tokenize import TokenError\n#         leading_space = re.compile(' *')\n#         spaces = re.match(leading_space, line).span()[1]\n#         try:\n#             return ' '*spaces + int_to_Integer(line)\n#         except TokenError:\n#             return line\n#\n# int_transformer = IntTransformer()\n#\n# def enable_automatic_int_sympification(app):\n#     \"\"\"\n#     Allow IPython to automatically convert integer literals to Integer.\n#\n#     This lets things like 1/2 be executed as (essentially) Rational(1, 2).\n#     \"\"\"\n#     app.shell.prefilter_manager.register_transformer(int_transformer)\n\ndef enable_automatic_int_sympification(app):\n    \"\"\"\n    Allow IPython to automatically convert integer literals to Integer.\n    \"\"\"\n    hasshell = hasattr(app, 'shell')\n\n    import ast\n    if hasshell:\n        old_run_cell = app.shell.run_cell\n    else:\n        old_run_cell = app.run_cell\n    def my_run_cell(cell, *args, **kwargs):\n        try:\n            # Check the cell for syntax errors.  This way, the syntax error\n            # will show the original input, not the transformed input.  The\n            # downside here is that IPython magic like %timeit will not work\n            # with transformed input (but on the other hand, IPython magic\n            # that doesn't expect transformed input will continue to work).\n            ast.parse(cell)\n        except SyntaxError:\n            pass\n        else:\n            cell = int_to_Integer(cell)\n        old_run_cell(cell, *args, **kwargs)\n\n    if hasshell:\n        app.shell.run_cell = my_run_cell\n    else:\n        app.run_cell = my_run_cell\n\ndef enable_automatic_symbols(app):\n    \"\"\"Allow IPython to automatially create symbols (``isympy -a``). \"\"\"\n    # XXX: This should perhaps use tokenize, like int_to_Integer() above.\n    # This would avoid re-executing the code, which can lead to subtle\n    # issues.  For example:\n    #\n    # In [1]: a = 1\n    #\n    # In [2]: for i in range(10):\n    #    ...:     a += 1\n    #    ...:\n    #\n    # In [3]: a\n    # Out[3]: 11\n    #\n    # In [4]: a = 1\n    #\n    # In [5]: for i in range(10):\n    #    ...:     a += 1\n    #    ...:     print b\n    #    ...:\n    # b\n    # b\n    # b\n    # b\n    # b\n    # b\n    # b\n    # b\n    # b\n    # b\n    #\n    # In [6]: a\n    # Out[6]: 12\n    #\n    # Note how the for loop is executed again because `b` was not defined, but `a`\n    # was already incremented once, so the result is that it is incremented\n    # multiple times.\n\n    import re\n    re_nameerror = re.compile(\"name '(?P<symbol>[A-Za-z_][A-Za-z0-9_]*)' is not defined\")\n\n    def _handler(self, etype, value, tb, tb_offset=None):\n        \"\"\"Handle :exc:`NameError` exception and allow injection of missing symbols. \"\"\"\n        if etype is NameError and tb.tb_next and not tb.tb_next.tb_next:\n            match = re_nameerror.match(str(value))\n\n            if match is not None:\n                # XXX: Make sure Symbol is in scope. Otherwise you'll get infinite recursion.\n                self.run_cell(\"%(symbol)s = Symbol('%(symbol)s')\" %\n                    {'symbol': match.group(\"symbol\")}, store_history=False)\n\n                try:\n                    code = self.user_ns['In'][-1]\n                except (KeyError, IndexError):\n                    pass\n                else:\n                    self.run_cell(code, store_history=False)\n                    return None\n                finally:\n                    self.run_cell(\"del %s\" % match.group(\"symbol\"),\n                                  store_history=False)\n\n        stb = self.InteractiveTB.structured_traceback(etype, value, tb, tb_offset=tb_offset)\n        self._showtraceback(etype, value, stb)\n\n    if hasattr(app, 'shell'):\n        app.shell.set_custom_exc((NameError,), _handler)\n    else:\n        # This was restructured in IPython 0.13\n        app.set_custom_exc((NameError,), _handler)\n\ndef init_ipython_session(argv=[], auto_symbols=False, auto_int_to_Integer=False):\n    \"\"\"Construct new IPython session. \"\"\"\n    import IPython\n\n    if IPython.__version__ >= '0.11':\n        # use an app to parse the command line, and init config\n        from IPython.frontend.terminal import ipapp\n        app = ipapp.TerminalIPythonApp()\n\n        # don't draw IPython banner during initialization:\n        app.display_banner = False\n        app.initialize(argv)\n\n        if auto_symbols:\n            enable_automatic_symbols(app)\n        if auto_int_to_Integer:\n            enable_automatic_int_sympification(app)\n\n        return app.shell\n    else:\n        from IPython.Shell import make_IPython\n        return make_IPython(argv)\n\ndef init_python_session():\n    \"\"\"Construct new Python session. \"\"\"\n    from code import InteractiveConsole\n\n    class SymPyConsole(InteractiveConsole):\n        \"\"\"An interactive console with readline support. \"\"\"\n\n        def __init__(self):\n            InteractiveConsole.__init__(self)\n\n            try:\n                import readline\n            except ImportError:\n                pass\n            else:\n                import os\n                import atexit\n\n                readline.parse_and_bind('tab: complete')\n\n                if hasattr(readline, 'read_history_file'):\n                    history = os.path.expanduser('~/.sympy-history')\n\n                    try:\n                        readline.read_history_file(history)\n                    except IOError:\n                        pass\n\n                    atexit.register(readline.write_history_file, history)\n\n    return SymPyConsole()\n\ndef init_session(ipython=None, pretty_print=True, order=None,\n        use_unicode=None, quiet=False, auto_symbols=False, auto_int_to_Integer=False, argv=[]):\n    \"\"\"\n    Initialize an embedded IPython or Python session. The IPython session is\n    initiated with the --pylab option, without the numpy imports, so that\n    matplotlib plotting can be interactive.\n\n    Parameters\n    ==========\n\n    pretty_print: boolean\n        If True, use pretty_print to stringify;\n        if False, use sstrrepr to stringify.\n    order: string or None\n        There are a few different settings for this parameter:\n        lex (default), which is lexographic order;\n        grlex, which is graded lexographic order;\n        grevlex, which is reversed graded lexographic order;\n        old, which is used for compatibility reasons and for long expressions;\n        None, which sets it to lex.\n    use_unicode: boolean or None\n        If True, use unicode characters;\n        if False, do not use unicode characters.\n    quiet: boolean\n        If True, init_session will not print messages regarding its status;\n        if False, init_session will print messages regarding its status.\n    auto_symbols: boolean\n        If True, IPython will automatically create symbols for you.\n        If False, it will not.\n        The default is False.\n    auto_int_to_Integer: boolean\n        If True, IPython will automatically wrap int literals with Integer, so\n        that things like 1/2 give Rational(1, 2).\n        If False, it will not.\n        The default is False.\n    ipython: boolean or None\n        If True, printing will initialize for an IPython console;\n        if False, printing will initialize for a normal console;\n        The default is None, which does what False does.\n    argv: list of arguments for IPython\n        See sympy.bin.isympy for options that can be used to initialize IPython.\n\n    See Also\n    ========\n\n    sympy.interactive.printing.init_printing: for examples and the rest of the parameters.\n\n\n    Examples\n    ========\n\n    >>> from sympy import init_session, Symbol, sin, sqrt\n    >>> sin(x) #doctest: +SKIP\n    NameError: name 'x' is not defined\n    >>> init_session() #doctest: +SKIP\n    >>> sin(x) #doctest: +SKIP\n    sin(x)\n    >>> sqrt(5) #doctest: +SKIP\n      ___\n    \\/ 5\n    >>> init_session(pretty_print=False) #doctest: +SKIP\n    >>> sqrt(5) #doctest: +SKIP\n    sqrt(5)\n    >>> y + x + y**2 + x**2 #doctest: +SKIP\n    x**2 + x + y**2 + y\n    >>> init_session(order='grlex') #doctest: +SKIP\n    >>> y + x + y**2 + x**2 #doctest: +SKIP\n    x**2 + y**2 + x + y\n    >>> init_session(order='grevlex') #doctest: +SKIP\n    >>> y * x**2 + x * y**2 #doctest: +SKIP\n    x**2*y + x*y**2\n    >>> init_session(order='old') #doctest: +SKIP\n    >>> x**2 + y**2 + x + y #doctest: +SKIP\n    x + y + x**2 + y**2\n    >>> theta = Symbol('theta') #doctest: +SKIP\n    >>> theta #doctest: +SKIP\n    theta\n    >>> init_session(use_unicode=True) #doctest: +SKIP\n    >>> theta # doctest: +SKIP\n    \\u03b8\n    \"\"\"\n    import sys\n\n    in_ipython = False\n\n    if ipython is False:\n        ip = init_python_session()\n        mainloop = ip.interact\n    else:\n        try:\n            import IPython\n        except ImportError:\n            if ipython is not True:\n                if not quiet:\n                    print no_ipython\n                ip = init_python_session()\n                mainloop = ip.interact\n            else:\n                raise RuntimeError(\"IPython is not available on this system\")\n        else:\n            ipython = True\n\n            if IPython.__version__ >= '0.11':\n                try:\n                    ip = get_ipython()\n                except NameError:\n                    ip = None\n            else:\n                ip = IPython.ipapi.get()\n                if ip:\n                    ip = ip.IP\n\n            if ip is not None:\n                in_ipython = True\n            else:\n                ip = init_ipython_session(argv=argv,\n                    auto_symbols=auto_symbols, auto_int_to_Integer=auto_int_to_Integer)\n\n            if IPython.__version__ >= '0.11':\n                # runsource is gone, use run_cell instead, which doesn't\n                # take a symbol arg.  The second arg is `store_history`,\n                # and False means don't add the line to IPython's history.\n                ip.runsource = lambda src, symbol='exec': ip.run_cell(src, False)\n\n                #Enable interactive plotting using pylab.\n                try:\n                    ip.enable_pylab(import_all=False)\n                except ImportError:\n                    #Causes an import error if matplotlib is not installed.\n                    pass\n            if not in_ipython:\n                mainloop = ip.mainloop\n\n    if auto_symbols and (not ipython or IPython.__version__ < '0.11'):\n        raise RuntimeError(\"automatic construction of symbols is possible only in IPython 0.11 or above\")\n    if auto_int_to_Integer and (not ipython or IPython.__version__ < '0.11'):\n        raise RuntimeError(\"automatic int to Integer transformation is possible only in IPython 0.11 or above\")\n\n    _preexec_source = preexec_source\n\n    ip.runsource(_preexec_source, symbol='exec')\n    init_printing(pretty_print=pretty_print, order=order, use_unicode=use_unicode, ip=ip)\n\n    message = _make_message(ipython, quiet, _preexec_source)\n\n    if not in_ipython:\n        mainloop(message)\n        sys.exit('Exiting ...')\n    else:\n        ip.write(message)\n        ip.set_hook('shutdown_hook', lambda ip: ip.write(\"Exiting ...\\n\"))\n", "meta": {"hexsha": "e6b20cf8cc610f36665e9f99ce6007046a71fb38", "size": 15104, "ext": "py", "lang": "Python", "max_stars_repo_path": "sympy/interactive/session.py", "max_stars_repo_name": "sn6uv/sympy", "max_stars_repo_head_hexsha": "5b149c2f72847e4785c65358b09d99b29f101dd5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sympy/interactive/session.py", "max_issues_repo_name": "sn6uv/sympy", "max_issues_repo_head_hexsha": "5b149c2f72847e4785c65358b09d99b29f101dd5", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sympy/interactive/session.py", "max_forks_repo_name": "sn6uv/sympy", "max_forks_repo_head_hexsha": "5b149c2f72847e4785c65358b09d99b29f101dd5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.4120171674, "max_line_length": 111, "alphanum_fraction": 0.5929555085, "include": true, "reason": "from sympy", "num_tokens": 3689, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.34510525748676846, "lm_q2_score": 0.14804719427274568, "lm_q1q2_score": 0.05109186509968953}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# <img style=\"float: left;padding: 1.3em\" src=\"https://indico.in2p3.fr/event/18313/logo-786578160.png\">  \n# \n# #  Gravitational Wave Open Data Workshop #3\n# \n# \n# #### Tutorial 1.2: Introduction to GWpy\n# \n# This tutorial will briefly describe GWpy, a python package for gravitational astrophysics, and walk-through how you can use this to speed up access to, and processing of, GWOSC data.\n#     \n# [Click this link to view this tutorial in Google Colaboratory](https://colab.research.google.com/github/gw-odw/odw-2019/blob/master/Day_1/Tuto%201.2%20Open%20Data%20access%20with%20GWpy.ipynb)\n# \n# <div class=\"alert alert-info\">This notebook were generated using python 3.7, but should work on python 2.7, 3.6, or 3.7.</div>\n\n# ##  Installation  (execute only if running on a cloud platform or if you haven't done the installation already!)\n# \n# Note: we use [`pip`](https://docs.python.org/3.6/installing/), but **it is recommended** to use [conda](https://docs.ligo.org/lscsoft/conda/) on your own machine, as explained in the [installation instructions](https://github.com/gw-odw/odw-2019/blob/master/setup.md). This usage might look a little different than normal, simply because we want to do this directly from the notebook.\n\n# In[2]:\n\n\n# -- Uncomment following line if running in Google Colab\n#! pip install -q 'gwpy==1.0.1'\n\n\n# **Important:** With Google Colab, you may need to restart the runtime after running the cell above.\n\n# ## Initialization\n\n# In[1]:\n\n\nimport gwpy\nprint(gwpy.__version__)\n\n\n# ## A note on object-oriented programming\n# \n# Before we dive too deeply, its worth a quick aside on object-oriented programming (OOP).\n# GWpy is heavily object-oriented, meaning almost all of the code you run using GWpy is based around an object of some type, e.g. `TimeSeries`.\n# Most of the methods (functions) we will use are attached to an object, rather than standing alone, meaning you should have a pretty good idea of what sort of data you are dealing with (without having to read the documentation!).\n# \n# For a quick overview of object-oriented programming in Python, see [this blog post by Jeff Knupp](https://jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/).\n\n# ## Handling data in the time domain\n\n# #### Finding open data\n# \n# We have seen already that the `gwosc` module can be used to query for what data are available on GWOSC.\n# The next thing to do is to actually read some open data. Let's try to get some for GW150914, the first direct detection of an astrophysical gravitational-wave signal from a BBH (binary black hole system).\n# \n# We can use the [`TimeSeries.fetch_open_data`](https://gwpy.github.io/docs/stable/api/gwpy.timeseries.TimeSeries.html#gwpy.timeseries.TimeSeries.fetch_open_data) method to download data directly from https://www.gw-openscience.org, but we need to know the GPS times.\n# We can query for the GPS time of an event as follows:\n\n# In[2]:\n\n\nfrom gwosc.datasets import event_gps\ngps = event_gps('GW150914')\nprint(gps)\n\n\n# Now we can build a `[start, end)` GPS segment to 10 seconds around this time, using integers for convenience:\n\n# In[3]:\n\n\nsegment = (int(gps)-5, int(gps)+5)\nprint(segment)\n\n\n# and can now query for the full data.\n# For this example we choose to retrieve data for the LIGO-Livingston interferometer, using the identifier `'L1'`.\n# We could have chosen any of\n# \n# - `'G1`' - GEO600\n# - `'H1'` - LIGO-Hanford\n# - `'L1'` - LIGO-Livingston\n# - `'V1'` - (Advanced) Virgo\n# \n# In the future, the Japanese observatory KAGRA will come online, with the identifier `'K1'`.\n\n# In[4]:\n\n\nfrom gwpy.timeseries import TimeSeries\nldata = TimeSeries.fetch_open_data('L1', *segment, verbose=True)\nprint(ldata)\n\n\n# ##### The `verbose=True` flag lets us see that GWpy has discovered two files that provides the data for the given interval, downloaded them, and loaded the data.\n# The files are not stored permanently, so next time you do the same call, it will be downloaded again, however, if you know you might repeat the same call many times, you can use `cache=True` to store the file on your computer.\n# \n# Notes: \n# \n# * To read data from a local file instead of from the GWOSC server, we can use [`TimeSeries.read`](https://gwpy.github.io/docs/stable/api/gwpy.timeseries.TimeSeries.html#gwpy.timeseries.TimeSeries.read) method.\n# \n# We have now downloaded real LIGO data for GW150914! These are the actual data used in the analysis that discovered the first binary black hole merger.\n\n# To sanity check things, we can easily make a plot, using the [`plot()`](https://gwpy.github.io/docs/stable/timeseries/plot.html) method of the `data` `TimeSeries`.\n\n# <div class=\"alert alert-info\">\n# Since this is the first time we are plotting something in this notebook, we need to make configure `matplotlib` (the plotting library) to work within the notebook properly:\n# </div>\n\n# Matplotlib documentation can be found [`here`](https://matplotlib.org/contents.html).\n\n# In[5]:\n\n\nget_ipython().run_line_magic('matplotlib', 'inline')\nplot = ldata.plot()\n\n\n# Notes: There are alternatives ways to access the GWOSC data. \n# \n# * [`readligo`](https://losc.ligo.org/s/sample_code/readligo.py) is a light-weight Python module that returns the time series into a Numpy array.\n# * The [PyCBC](http://github.com/ligo-cbc/pycbc) package has the `pycbc.frame.query_and_read_frame` and `pycbc.frame.read_frame` methods. We use [PyCBC](http://github.com/ligo-cbc/pycbc) in Tutorial 2.1, 2.2 and 2.3. \n\n# ## Handling data in the frequency domain using the Fourier transform\n# \n# The [Fourier transform](https://en.wikipedia.org/wiki/Fourier_transform) is a widely-used mathematical tool to expose the frequency-domain content of a time-domain signal, meaning we can see which frequencies contian lots of power, and which have less.\n# \n# We can calculate the Fourier transform of our `TimeSeries` using the [`fft()`](https://gwpy.github.io/docs/stable/api/gwpy.timeseries.TimeSeries.html#gwpy.timeseries.TimeSeries.fft) method:\n\n# In[6]:\n\n\nfft = ldata.fft()\nprint(fft)\n\n\n# The result is a [`FrequencySeries`](https://gwpy.github.io/docs/stable/frequencyseries/), with complex amplitude, representing the amplitude and phase of each frequency in our data.\n# We can use `abs()` to extract the amplitude and plot that:\n\n# In[7]:\n\n\nplot = fft.abs().plot(xscale=\"log\", yscale=\"log\")\nplot.show(warn=False)\n\n\n# This doesn't look correct at all!\n# The problem is that the FFT works under the assumption that our data are periodic, which means that the edges of our data look like discontinuities when transformed.\n# We need to apply a window function to our time-domain data before transforming, which we can do using the [`scipy.signal`](https://docs.scipy.org/doc/scipy/reference/signal.html) module:\n\n# In[8]:\n\n\nfrom scipy.signal import get_window\nwindow = get_window('hann', ldata.size)\nlwin = ldata * window\n\n\n# Let's try our transform again and see what we get\n\n# In[9]:\n\n\nfftamp = lwin.fft().abs()\nplot = fftamp.plot(xscale=\"log\", yscale=\"log\")\nplot.show(warn=False)\n\n\n# This looks a little more like what we expect for the amplitude spectral density of a gravitational-wave detector.\n\n# ## Calculating the power spectral density\n# \n# In practice, we typically use a large number of FFTs to estimate an averages power spectral density over a long period of data.\n# We can do this using the [`asd()`](https://gwpy.github.io/docs/stable/api/gwpy.timeseries.TimeSeries.html#gwpy.timeseries.TimeSeries.asd) method, which uses [Welch's method](https://en.wikipedia.org/wiki/Welch%27s_method) to combine FFTs of overlapping, windowed chunks of data.\n\n# In[10]:\n\n\nasd = ldata.asd(fftlength=4, method=\"median\")\nplot = asd.plot()\nplot.show(warn=False)\n\n\n# In[11]:\n\n\nax = plot.gca()\nax.set_xlim(10, 1400)\nax.set_ylim(2e-24, 1e-20)\nplot\n\n\n# The ASD is a standard tool used to study the frequency-domain sensitivity of a gravitational-wave detector.\n# For the LIGO-Livingston data we loaded, we can see large spikes at certain frequencies, including\n# \n# - ~300 Hz\n# - ~500 Hz\n# - ~1000 Hz\n# \n# The [O2 spectral lines](https://www.gw-openscience.org/o2speclines/) page on GWOSC describes a number of these spectral features for O2, with some of them being forced upon us, and some being deliberately introduced to help with interferometer control.\n# \n# Loading more data allows for more FFTs to be averaged during the ASD calculation, meaning random variations get averaged out, and we can see more detail:\n\n# In[12]:\n\n\nldata2 = TimeSeries.fetch_open_data('L1', int(gps)-512, int(gps)+512, cache=True)\nlasd2 = ldata2.asd(fftlength=4, method=\"median\")\nplot = lasd2.plot()\nax = plot.gca()\nax.set_xlim(10, 1400)\nax.set_ylim(5e-24, 1e-20)\nplot.show(warn=False)\n\n\n# Now we can see some more features, including sets of lines around ~30 Hz and ~65 Hz, and some more isolate lines through the more sensitive region.\n# \n# For comparison, we can load the LIGO-Hanford data and plot that as well:\n\n# In[13]:\n\n\n# get Hanford data\nhdata2 = TimeSeries.fetch_open_data('H1', int(gps)-512, int(gps)+512, cache=True)\nhasd2 = hdata2.asd(fftlength=4, method=\"median\")\n\n# and plot using standard colours\nax.plot(hasd2, label='LIGO-Hanford', color='gwpy:ligo-hanford')\n\n# update the Livingston line to use standard colour, and have a label\nlline = ax.lines[0]\nlline.set_color('gwpy:ligo-livingston')  # change colour of Livingston data\nlline.set_label('LIGO-Livingston')\n\nax.set_ylabel(r'Strain noise [$1/\\sqrt{\\mathrm{Hz}}$]')\nax.legend()\nplot\n\n\n# Now we can see clearly the relative sensitivity of each LIGO instrument, the common features between both, and those unique to each observatory.\n\n# # Challenges:\n\n# ##### Quiz Question 1:\n# \n# The peak amplitude in the LIGO-Livingston data occurs at approximately 5 seconds into the plot above and is undetectable above the background noise by the eye. Plot the data for the LIGO-Hanford detector around GW150914. Looking at your new LIGO-Handford plot, can your eye identify a signal peak? \n\n# In[14]:\n\n\nfrom gwosc.datasets import event_gps\ngps1 = event_gps('GW150914')\nprint(gps1)\nsegment1 = (int(gps)-7, int(gps)+7)\nprint(segment1)\n\nfrom gwpy.timeseries import TimeSeries\nldata1 = TimeSeries.fetch_open_data('L1', *segment1, verbose=True)\nprint(ldata1)\n\nget_ipython().run_line_magic('matplotlib', 'inline')\nplot1 = ldata1.plot()\n\n\n# In[24]:\n\n\nimport matplotlib.pyplot as plt\n\nldata2 = TimeSeries.fetch_open_data('L1', int(gps)-512, int(gps)+512, cache=True)\nlasd2 = ldata2.asd(fftlength=4, method=\"median\")\n\n# get Hanford data\nhdata2 = TimeSeries.fetch_open_data('H1', int(gps)-512, int(gps)+512, cache=True)\nhasd2 = hdata2.asd(fftlength=4, method=\"median\")\n\nfig, ax = plt.subplots(figsize=(13,7))\n# and plot using standard colours\nax.plot(hasd2, label='LIGO-Hanford', color='gwpy:ligo-hanford')\nax.plot(lasd2, label='LIGO-Livingston', color='gwpy:ligo-livingston')\n\nax.set_xlim(2, 1400)\nax.set_ylim(5e-24, 2e-19)\n# update the Livingston line to use standard colour, and have a label\n\nax.set_yscale('log')\nax.set_xscale('log')\nax.set_ylabel(r'Strain noise [$1/\\sqrt{\\mathrm{Hz}}$]')\nax.set_xlabel(r'Frequency [Hz]')\n\nax.legend()\nplt.show()\n\n\n# # Quiz Question 2 :\n# \n# Make an ASD around the time of an O3 event, GW190412 for L1 detector .  Compare this with the ASDs around GW150914 for L1 detector.  Which data have lower noise - and so are more sensitive - around 100 Hz?\n# \n\n# In[25]:\n\n\nfrom gwosc.datasets import event_gps\ngps_GW190412 = event_gps('GW190412')\nprint(gps_GW190412)\nsegment_GW190412 = (int(gps_GW190412)-7, int(gps_GW190412)+7)\nprint(segment_GW190412)\n\nfrom gwpy.timeseries import TimeSeries\nldata_GW190412 = TimeSeries.fetch_open_data('L1', *segment_GW190412, verbose=True)\nprint(ldata_GW190412)\n\nget_ipython().run_line_magic('matplotlib', 'inline')\nplot_GW190412 = ldata_GW190412.plot()\n\n\n# In[32]:\n\n\nimport matplotlib.pyplot as plt\n\nldata_GW190412 = TimeSeries.fetch_open_data('L1', int(gps_GW190412)-512, int(gps_GW190412)+512, cache=True)\nlasd_GW190412 = ldata_GW190412.asd(fftlength=4, method=\"median\")\n\n# get Hanford data\nhdata_GW190412 = TimeSeries.fetch_open_data('H1', int(gps_GW190412)-512, int(gps_GW190412)+512, cache=True)\nhasd_GW190412 = hdata_GW190412.asd(fftlength=4, method=\"median\")\n\nfig, ax = plt.subplots(figsize=(13,7))\n# and plot using standard colours\nax.plot(hasd_GW190412, label='LIGO-Hanford', color='gwpy:ligo-hanford')\nax.plot(lasd_GW190412, label='LIGO-Livingston', color='gwpy:ligo-livingston')\n\nax.set_xlim(2, 1400)\nax.set_ylim(4e-24, 7e-19)\n# update the Livingston line to use standard colour, and have a label\n\nax.set_yscale('log')\nax.set_xscale('log')\nax.set_ylabel(r'Strain noise [$1/\\sqrt{\\mathrm{Hz}}$]')\nax.set_xlabel(r'Frequency [Hz]')\n\nax.legend()\nplt.show()\n\n\n# In[33]:\n\n\nimport matplotlib.pyplot as plt\n\nldata_GW190412 = TimeSeries.fetch_open_data('L1', int(gps_GW190412)-512, int(gps_GW190412)+512, cache=True)\nlasd_GW190412 = ldata_GW190412.asd(fftlength=4, method=\"median\")\n\nldata2 = TimeSeries.fetch_open_data('L1', int(gps)-512, int(gps)+512, cache=True)\nlasd2 = ldata2.asd(fftlength=4, method=\"median\")\n\nfig, ax = plt.subplots(figsize=(13,7))\n# and plot using standard colours\nax.plot(lasd2, label='LIGO-L1-GW150914', color='blue')\nax.plot(lasd_GW190412, label='LIGO-L1-GW190412', color='green')\n\nax.set_xlim(2, 1400)\nax.set_ylim(4e-24, 7e-19)\n# update the Livingston line to use standard colour, and have a label\n\nax.set_yscale('log')\nax.set_xscale('log')\nax.set_ylabel(r'Strain noise [$1/\\sqrt{\\mathrm{Hz}}$]')\nax.set_xlabel(r'Frequency [Hz]')\n\nax.legend()\nplt.show()\n\n\n# # The GW190412 data has lesser noise around 100 Hz\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "852372bac5ab0b8c0199e3f5cb3a8cae2a663545", "size": 13657, "ext": "py", "lang": "Python", "max_stars_repo_path": "gw-odw_Day1_with_Solns/Tuto 1.2 Open Data access with GWpy with solutions.py", "max_stars_repo_name": "basuparth/grav_wave_workshop3", "max_stars_repo_head_hexsha": "eb9e2ff066bb1928e5a1dbc8cd8d24344515aae4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gw-odw_Day1_with_Solns/Tuto 1.2 Open Data access with GWpy with solutions.py", "max_issues_repo_name": "basuparth/grav_wave_workshop3", "max_issues_repo_head_hexsha": "eb9e2ff066bb1928e5a1dbc8cd8d24344515aae4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gw-odw_Day1_with_Solns/Tuto 1.2 Open Data access with GWpy with solutions.py", "max_forks_repo_name": "basuparth/grav_wave_workshop3", "max_forks_repo_head_hexsha": "eb9e2ff066bb1928e5a1dbc8cd8d24344515aae4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.845144357, "max_line_length": 386, "alphanum_fraction": 0.7422567182, "include": true, "reason": "from scipy", "num_tokens": 3803, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3738758367247085, "lm_q2_score": 0.13660840408654296, "lm_q1q2_score": 0.05107458138148333}}
{"text": "\n# python src/chapter3/chapter3_2.py\n# python3 src/chapter3/chapter3_2.py\nfrom __future__ import division, absolute_import, print_function\nimport sys\nimport math\n\nfrom copy import copy\nfrom copy import deepcopy\n\nimport numpy as np\nfrom numpy import arange\n\nfrom matplotlib.pyplot import plot\nfrom matplotlib.pyplot import figure\nfrom matplotlib.pyplot import show\n\n\nclass Chapter3_2:\n    '''\n    CLRS 第三章 3.2 算法函数和笔记\n    '''\n    def note(self):\n        '''\n        Summary\n        =\n        Print chapter3.2 note\n\n        Example\n        =\n        >>> Chapter3_2().note()\n        '''\n        print('3.2 标准记号和常用函数')\n        print('单调性：一个函数f(n)是单调递增的，若m<=n,则有f(m)<=f(n)，反之单调递减，将小于等于号换成小于号，即变为严格不等式，则函数是严格单调递增的')\n        print('下取整(floor)和上取整(ceiling)')\n        print('取模运算(modular arithmetic)')\n        print('多项式定义及其性质')\n        print('指数式定义及其性质')\n        print('任何底大于1的指数函数比任何多项式函数增长得更快')\n        print('对数定义及其性质')\n        print('阶乘定义及其性质')\n        print('计算机工作者常常认为对数的底取2最自然，因为很多算法和数据结构都涉及到对问题进行二分')\n        print('任意正的多项式函数都比多项对数函数增长得快')\n        print('斯特林近似公式：n!=sqrt(2*pi*n)*(n/e)^n*(1+Θ(1/n))')\n        print('阶乘函数的一个更紧确的上界和下界：')\n        print('n!=o(n^n) n!=ω(2^n) lg(n!)=Θ(nlgn)')\n        print('函数迭代的定义和性质')\n        print('多重对数函数：用记号lg * n(读作n的log星)来表示多重对数，定义为lg * n=min(i>=0;lg^(i)n<=1)')\n        print('多重函数是一种增长很慢的函数')\n        print('lg * 2 = 1; lg * 4 = 2; lg * 16 = 3; lg * 65536 = 4; lg * 2^65536 = 5')\n        print('宇宙中可以观察到的原子数目估计约有10^80，远远小于2^65536,因此很少会遇到一个使lg * n > 5的一个n输入规模')\n        print('斐波那契数列：F0 = 0 F1 = 1 F(i) = F(i-1) + F(i-2),产生的序列为0,1,1,2,3,5,8,13,21,34,55,……')\n        print('斐波那契数列和黄金分割率φ以及共轭有关系')\n        print('φ=((1+sqrt(5))/2=1.61803 和它的共轭(1-sqrt(5))/2=-0.61803)')\n        print('练习题和思考题略')\n        # python src/chapter3/chapter3_2.py\n        # python3 src/chapter3/chapter3_2.py\n        return self\n        \nif __name__ == '__main__':\n    print('Run main : single chapter three!')\n    Chapter3_2().note()\nelse:\n    pass\n", "meta": {"hexsha": "35f9f03fb30ac52294b96b2eb0adf1416a226747", "size": 1958, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/chapter3/chapter3_2.py", "max_stars_repo_name": "Peefy/CLRS_dugu_code-master", "max_stars_repo_head_hexsha": "98f00e75e1b0ebc13a7affb2604bec8501692a19", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-01-31T03:08:50.000Z", "max_stars_repo_stars_event_max_datetime": "2018-04-25T12:57:01.000Z", "max_issues_repo_path": "src/chapter3/chapter3_2.py", "max_issues_repo_name": "HideLakitu/IntroductionToAlgorithm.Python", "max_issues_repo_head_hexsha": "33662f46dc346203b220d7481d1a4439feda05d2", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/chapter3/chapter3_2.py", "max_forks_repo_name": "HideLakitu/IntroductionToAlgorithm.Python", "max_forks_repo_head_hexsha": "33662f46dc346203b220d7481d1a4439feda05d2", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-03-03T04:49:53.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-13T10:18:58.000Z", "avg_line_length": 30.1230769231, "max_line_length": 95, "alphanum_fraction": 0.6036772217, "include": true, "reason": "import numpy,from numpy", "num_tokens": 913, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46490157137338844, "lm_q2_score": 0.10970577242256814, "lm_q1q2_score": 0.05100238598798327}}
{"text": "\"\"\"\nGenerators for some classic graphs.\n\nThe typical graph generator is called as follows:\n\n>>> G=nx.complete_graph(100)\n\nreturning the complete graph on n nodes labeled 0,..,99\nas a simple graph. Except for empty_graph, all the generators\nin this module return a Graph class (i.e. a simple, undirected graph).\n\n\"\"\"\n#    Copyright (C) 2004-2010 by\n#    Aric Hagberg <hagberg@lanl.gov>\n#    Dan Schult <dschult@colgate.edu>\n#    Pieter Swart <swart@lanl.gov>\n#    All rights reserved.\n#    BSD license.\nimport itertools\nfrom networkx.algorithms.bipartite.generators import complete_bipartite_graph\n__author__ =\"\"\"Aric Hagberg (hagberg@lanl.gov)\\nPieter Swart (swart@lanl.gov)\"\"\"\n\n__all__ = [ 'balanced_tree',\n            'barbell_graph',\n            'complete_graph',\n            'circular_ladder_graph',\n            'cycle_graph',\n            'dorogovtsev_goltsev_mendes_graph',\n            'empty_graph',\n            'full_rary_tree',\n            'grid_graph',\n            'grid_2d_graph',\n            'hypercube_graph',\n            'ladder_graph',\n            'lollipop_graph',\n            'null_graph',\n            'path_graph',\n            'star_graph',\n            'trivial_graph',\n            'wheel_graph']\n\n\n#-------------------------------------------------------------------\n#   Some Classic Graphs\n#-------------------------------------------------------------------\nimport networkx as nx\nfrom networkx.utils import is_list_of_ints, flatten\n\ndef _tree_edges(n,r):\n    # helper function for trees\n    # yields edges in rooted tree at 0 with n nodes and branching ratio r\n    nodes=iter(range(n))\n    parents=[next(nodes)] # stack of max length r\n    while parents:\n        source=parents.pop(0)\n        for i in range(r):\n            try:\n                target=next(nodes)\n                parents.append(target)\n                yield source,target\n            except StopIteration:\n                break\n\ndef full_rary_tree(r, n, create_using=None):\n    \"\"\"Creates a full r-ary tree of n vertices.\n\n    Sometimes called a k-ary, n-ary, or m-ary tree.  \"... all non-leaf\n    vertices have exactly r children and all levels are full except\n    for some rightmost position of the bottom level (if a leaf at the\n    bottom level is missing, then so are all of the leaves to its\n    right.\" [1]_\n\n    Parameters\n    ----------\n    r : int\n        branching factor of the tree\n    n : int\n        Number of nodes in the tree\n    create_using : NetworkX graph type, optional\n        Use specified type to construct graph (default = networkx.Graph)\n\n    Returns\n    -------\n    G : networkx Graph\n        An r-ary tree with n nodes\n\n    References\n    ----------\n    .. [1] An introduction to data structures and algorithms,\n           James Andrew Storer,  Birkhauser Boston 2001, (page 225).\n    \"\"\"\n    G=nx.empty_graph(n,create_using)\n    G.add_edges_from(_tree_edges(n,r))\n    return G\n\ndef balanced_tree(r, h, create_using=None):\n    \"\"\"Return the perfectly balanced r-tree of height h.\n\n    Parameters\n    ----------\n    r : int\n        Branching factor of the tree\n    h : int\n        Height of the tree\n    create_using : NetworkX graph type, optional\n        Use specified type to construct graph (default = networkx.Graph)\n\n    Returns\n    -------\n    G : networkx Graph\n        A tree with n nodes\n\n    Notes\n    -----\n    This is the rooted tree where all leaves are at distance h from\n    the root. The root has degree r and all other internal nodes have\n    degree r+1.\n\n    Node labels are the integers 0 (the root) up to  number_of_nodes - 1.\n\n    Also refered to as a complete r-ary tree.\n    \"\"\"\n    # number of nodes is n=1+r+..+r^h\n    if r==1:\n        n=2\n    else:\n        n = int((1-r**(h+1))/(1-r)) # sum of geometric series r!=1\n    G=nx.empty_graph(n,create_using)\n    G.add_edges_from(_tree_edges(n,r))\n    return G\n\n    return nx.full_rary_tree(r,n,create_using)\n\ndef barbell_graph(m1,m2,create_using=None):\n    \"\"\"Return the Barbell Graph: two complete graphs connected by a path.\n\n    For m1 > 1 and m2 >= 0.\n\n    Two identical complete graphs K_{m1} form the left and right bells,\n    and are connected by a path P_{m2}.\n\n    The 2*m1+m2  nodes are numbered\n        0,...,m1-1 for the left barbell,\n        m1,...,m1+m2-1 for the path,\n        and m1+m2,...,2*m1+m2-1 for the right barbell.\n\n    The 3 subgraphs are joined via the edges (m1-1,m1) and (m1+m2-1,m1+m2).\n    If m2=0, this is merely two complete graphs joined together.\n\n    This graph is an extremal example in David Aldous\n    and Jim Fill's etext on Random Walks on Graphs.\n\n    \"\"\"\n    if create_using is not None and create_using.is_directed():\n        raise nx.NetworkXError(\"Directed Graph not supported\")\n    if m1<2:\n        raise nx.NetworkXError(\\\n              \"Invalid graph description, m1 should be >=2\")\n    if m2<0:\n        raise nx.NetworkXError(\\\n              \"Invalid graph description, m2 should be >=0\")\n\n    # left barbell\n    G=complete_graph(m1,create_using)\n    G.name=\"barbell_graph(%d,%d)\"%(m1,m2)\n\n    # connecting path\n    G.add_nodes_from([v for v in range(m1,m1+m2-1)])\n    if m2>1:\n        G.add_edges_from([(v,v+1) for v in range(m1,m1+m2-1)])\n    # right barbell\n    G.add_edges_from( (u,v) for u in range(m1+m2,2*m1+m2) for v in range(u+1,2*m1+m2))\n    # connect it up\n    G.add_edge(m1-1,m1)\n    if m2>0:\n        G.add_edge(m1+m2-1,m1+m2)\n    return G\n\ndef complete_graph(n,create_using=None):\n    \"\"\" Return the complete graph K_n with n nodes.\n\n    Node labels are the integers 0 to n-1.\n    \"\"\"\n    G=empty_graph(n,create_using)\n    G.name=\"complete_graph(%d)\"%(n)\n    if n>1:\n        if G.is_directed():\n            edges=itertools.permutations(range(n),2)\n        else:\n            edges=itertools.combinations(range(n),2)\n        G.add_edges_from(edges)\n    return G\n\n\ndef circular_ladder_graph(n,create_using=None):\n    \"\"\"Return the circular ladder graph CL_n of length n.\n\n    CL_n consists of two concentric n-cycles in which\n    each of the n pairs of concentric nodes are joined by an edge.\n\n    Node labels are the integers 0 to n-1\n\n    \"\"\"\n    G=ladder_graph(n,create_using)\n    G.name=\"circular_ladder_graph(%d)\"%n\n    G.add_edge(0,n-1)\n    G.add_edge(n,2*n-1)\n    return G\n\ndef cycle_graph(n,create_using=None):\n    \"\"\"Return the cycle graph C_n over n nodes.\n\n    C_n is the n-path with two end-nodes connected.\n\n    Node labels are the integers 0 to n-1\n    If create_using is a DiGraph, the direction is in increasing order.\n\n    \"\"\"\n    G=path_graph(n,create_using)\n    G.name=\"cycle_graph(%d)\"%n\n    if n>1: G.add_edge(n-1,0)\n    return G\n\ndef dorogovtsev_goltsev_mendes_graph(n,create_using=None):\n    \"\"\"Return the hierarchically constructed Dorogovtsev-Goltsev-Mendes graph.\n\n    n is the generation.\n    See: arXiv:/cond-mat/0112143 by Dorogovtsev, Goltsev and Mendes.\n\n    \"\"\"\n    if create_using is not None:\n        if create_using.is_directed():\n            raise nx.NetworkXError(\"Directed Graph not supported\")\n        if create_using.is_multigraph():\n            raise nx.NetworkXError(\"Multigraph not supported\")\n    G=empty_graph(0,create_using)\n    G.name=\"Dorogovtsev-Goltsev-Mendes Graph\"\n    G.add_edge(0,1)\n    if n==0:\n        return G\n    new_node = 2         # next node to be added\n    for i in range(1,n+1): #iterate over number of generations.\n        last_generation_edges = G.edges()\n        number_of_edges_in_last_generation = len(last_generation_edges)\n        for j in range(0,number_of_edges_in_last_generation):\n            G.add_edge(new_node,last_generation_edges[j][0])\n            G.add_edge(new_node,last_generation_edges[j][1])\n            new_node += 1\n    return G\n\ndef empty_graph(n=0,create_using=None):\n    \"\"\"Return the empty graph with n nodes and zero edges.\n\n    Node labels are the integers 0 to n-1\n\n    For example:\n    >>> G=nx.empty_graph(10)\n    >>> G.number_of_nodes()\n    10\n    >>> G.number_of_edges()\n    0\n\n    The variable create_using should point to a \"graph\"-like object that\n    will be cleaned (nodes and edges will be removed) and refitted as\n    an empty \"graph\" with n nodes with integer labels. This capability\n    is useful for specifying the class-nature of the resulting empty\n    \"graph\" (i.e. Graph, DiGraph, MyWeirdGraphClass, etc.).\n\n    The variable create_using has two main uses:\n    Firstly, the variable create_using can be used to create an\n    empty digraph, network,etc.  For example,\n\n    >>> n=10\n    >>> G=nx.empty_graph(n,create_using=nx.DiGraph())\n\n    will create an empty digraph on n nodes.\n\n    Secondly, one can pass an existing graph (digraph, pseudograph,\n    etc.) via create_using. For example, if G is an existing graph\n    (resp. digraph, pseudograph, etc.), then empty_graph(n,create_using=G)\n    will empty G (i.e. delete all nodes and edges using G.clear() in\n    base) and then add n nodes and zero edges, and return the modified\n    graph (resp. digraph, pseudograph, etc.).\n\n    See also create_empty_copy(G).\n\n    \"\"\"\n    if create_using is None:\n        # default empty graph is a simple graph\n        G=nx.Graph()\n    else:\n        G=create_using\n        G.clear()\n\n    G.add_nodes_from(range(n))\n    G.name=\"empty_graph(%d)\"%n\n    return G\n\ndef grid_2d_graph(m,n,periodic=False,create_using=None):\n    \"\"\" Return the 2d grid graph of mxn nodes,\n        each connected to its nearest neighbors.\n        Optional argument periodic=True will connect\n        boundary nodes via periodic boundary conditions.\n    \"\"\"\n    G=empty_graph(0,create_using)\n    G.name=\"grid_2d_graph\"\n    rows=range(m)\n    columns=range(n)\n    G.add_nodes_from( (i,j) for i in rows for j in columns )\n    G.add_edges_from( ((i,j),(i-1,j)) for i in rows for j in columns if i>0 )\n    G.add_edges_from( ((i,j),(i,j-1)) for i in rows for j in columns if j>0 )\n    if G.is_directed():\n        G.add_edges_from( ((i,j),(i+1,j)) for i in rows for j in columns if i<m-1 )\n        G.add_edges_from( ((i,j),(i,j+1)) for i in rows for j in columns if j<n-1 )\n    if periodic:\n        if n>2:\n            G.add_edges_from( ((i,0),(i,n-1)) for i in rows )\n            if G.is_directed():\n                G.add_edges_from( ((i,n-1),(i,0)) for i in rows )\n        if m>2:\n            G.add_edges_from( ((0,j),(m-1,j)) for j in columns )\n            if G.is_directed():\n                G.add_edges_from( ((m-1,j),(0,j)) for j in columns )\n        G.name=\"periodic_grid_2d_graph(%d,%d)\"%(m,n)\n    return G\n\n\ndef grid_graph(dim,periodic=False):\n    \"\"\" Return the n-dimensional grid graph.\n\n    The dimension is the length of the list 'dim' and the\n    size in each dimension is the value of the list element.\n\n    E.g. G=grid_graph(dim=[2,3]) produces a 2x3 grid graph.\n\n    If periodic=True then join grid edges with periodic boundary conditions.\n\n    \"\"\"\n    dlabel=\"%s\"%dim\n    if dim==[]:\n        G=empty_graph(0)\n        G.name=\"grid_graph(%s)\"%dim\n        return G\n    if not is_list_of_ints(dim):\n        raise nx.NetworkXError(\"dim is not a list of integers\")\n    if min(dim)<=0:\n        raise nx.NetworkXError(\\\n              \"dim is not a list of strictly positive integers\")\n    if periodic:\n        func=cycle_graph\n    else:\n        func=path_graph\n\n    dim=list(dim)\n    current_dim=dim.pop()\n    G=func(current_dim)\n    while len(dim)>0:\n        current_dim=dim.pop()\n        # order matters: copy before it is cleared during the creation of Gnew\n        Gold=G.copy()\n        Gnew=func(current_dim)\n        # explicit: create_using=None\n        # This is so that we get a new graph of Gnew's class.\n        G=nx.cartesian_product(Gnew,Gold)\n    # graph G is done but has labels of the form (1,(2,(3,1)))\n    # so relabel\n    H=nx.relabel_nodes(G, flatten)\n    H.name=\"grid_graph(%s)\"%dlabel\n    return H\n\ndef hypercube_graph(n):\n    \"\"\"Return the n-dimensional hypercube.\n\n    Node labels are the integers 0 to 2**n - 1.\n\n    \"\"\"\n    dim=n*[2]\n    G=grid_graph(dim)\n    G.name=\"hypercube_graph_(%d)\"%n\n    return G\n\ndef ladder_graph(n,create_using=None):\n    \"\"\"Return the Ladder graph of length n.\n\n    This is two rows of n nodes, with\n    each pair connected by a single edge.\n\n    Node labels are the integers 0 to 2*n - 1.\n\n    \"\"\"\n    if create_using is not None and create_using.is_directed():\n        raise nx.NetworkXError(\"Directed Graph not supported\")\n    G=empty_graph(2*n,create_using)\n    G.name=\"ladder_graph_(%d)\"%n\n    G.add_edges_from([(v,v+1) for v in range(n-1)])\n    G.add_edges_from([(v,v+1) for v in range(n,2*n-1)])\n    G.add_edges_from([(v,v+n) for v in range(n)])\n    return G\n\ndef lollipop_graph(m,n,create_using=None):\n    \"\"\"Return the Lollipop Graph; `K_m` connected to `P_n`.\n\n    This is the Barbell Graph without the right barbell.\n\n    For m>1 and n>=0, the complete graph K_m is connected to the\n    path P_n.  The resulting m+n nodes are labelled 0,...,m-1 for the\n    complete graph and m,...,m+n-1 for the path. The 2 subgraphs\n    are joined via the edge (m-1,m).  If n=0, this is merely a complete\n    graph.\n\n    Node labels are the integers 0 to number_of_nodes - 1.\n\n    (This graph is an extremal example in David Aldous and Jim\n    Fill's etext on Random Walks on Graphs.)\n\n    \"\"\"\n    if create_using is not None and create_using.is_directed():\n        raise nx.NetworkXError(\"Directed Graph not supported\")\n    if m<2:\n        raise nx.NetworkXError(\\\n              \"Invalid graph description, m should be >=2\")\n    if n<0:\n        raise nx.NetworkXError(\\\n              \"Invalid graph description, n should be >=0\")\n    # the ball\n    G=complete_graph(m,create_using)\n    # the stick\n    G.add_nodes_from([v for v in range(m,m+n)])\n    if n>1:\n        G.add_edges_from([(v,v+1) for v in range(m,m+n-1)])\n    # connect ball to stick\n    if m>0: G.add_edge(m-1,m)\n    G.name=\"lollipop_graph(%d,%d)\"%(m,n)\n    return G\n\n\ndef null_graph(create_using=None):\n    \"\"\"Return the Null graph with no nodes or edges.\n\n    See empty_graph for the use of create_using.\n\n    \"\"\"\n    G=empty_graph(0,create_using)\n    G.name=\"null_graph()\"\n    return G\n\ndef path_graph(n,create_using=None):\n    \"\"\"Return the Path graph P_n of n nodes linearly connected by n-1 edges.\n\n    Node labels are the integers 0 to n - 1.\n    If create_using is a DiGraph then the edges are directed in\n    increasing order.\n\n    \"\"\"\n    G=empty_graph(n,create_using)\n    G.name=\"path_graph(%d)\"%n\n    G.add_edges_from([(v,v+1) for v in range(n-1)])\n    return G\n\ndef star_graph(n,create_using=None):\n    \"\"\" Return the Star graph with n+1 nodes: one center node, connected to n outer nodes.\n\n   Node labels are the integers 0 to n.\n\n    \"\"\"\n    G=complete_bipartite_graph(1,n,create_using)\n    G.name=\"star_graph(%d)\"%n\n    return G\n\ndef trivial_graph(create_using=None):\n    \"\"\" Return the Trivial graph with one node (with integer label 0) and no edges.\n\n    \"\"\"\n    G=empty_graph(1,create_using)\n    G.name=\"trivial_graph()\"\n    return G\n\ndef wheel_graph(n,create_using=None):\n    \"\"\" Return the wheel graph: a single hub node connected to each node of the (n-1)-node cycle graph.\n\n   Node labels are the integers 0 to n - 1.\n\n    \"\"\"\n    if n == 0:\n        return nx.empty_graph(n, create_using=create_using)\n    G=star_graph(n-1,create_using)\n    G.name=\"wheel_graph(%d)\"%n\n    G.add_edges_from([(v,v+1) for v in range(1,n-1)])\n    if n>2:\n        G.add_edge(1,n-1)\n    return G\n\n", "meta": {"hexsha": "3f12d87314d4bc80940d5a558c29e90ebee7078a", "size": 15334, "ext": "py", "lang": "Python", "max_stars_repo_path": "networkx/generators/classic.py", "max_stars_repo_name": "jni/networkx", "max_stars_repo_head_hexsha": "d15361da366b77573777a1542741387c29f34717", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "networkx/generators/classic.py", "max_issues_repo_name": "jni/networkx", "max_issues_repo_head_hexsha": "d15361da366b77573777a1542741387c29f34717", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "networkx/generators/classic.py", "max_forks_repo_name": "jni/networkx", "max_forks_repo_head_hexsha": "d15361da366b77573777a1542741387c29f34717", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.1034482759, "max_line_length": 103, "alphanum_fraction": 0.632450763, "include": true, "reason": "import networkx,from networkx", "num_tokens": 4192, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.45713671682749474, "lm_q2_score": 0.11124121240045177, "lm_q1q2_score": 0.05085244261265252}}
{"text": "# -*- coding: utf-8 -*-\n\n# Copyright (c) 2012, Sergio Callegari\n# All rights reserved.\n\n# This file is part of PyDSM.\n\n# PyDSM is free software: you can redistribute it and/or modify it\n# under the terms of the GNU General Public License as published by\n# the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n\n# PyDSM is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n# GNU General Public License for more details.\n\n# You should have received a copy of the GNU General Public License\n# along with PyDSM.  If not, see <http://www.gnu.org/licenses/>.\n\n\"\"\"\nCompatibility functions for PyDSM (:mod:`pydsm.relab`)\n======================================================\n\nThis module re-implements some Matlab interfaces that are useful\nfor PyDSM.\n\n.. currentmodule:: pydsm.relab\n\n\nFunctions\n---------\n\n.. autosummary::\n   :toctree: generated/\n\n   eps       -- Floating point relative accuracy\n   db        -- Converts a value to dB a la Matlab\n   cplxpair  -- Sorts values in input list by complex pairs\n   shiftdim  -- Shift dimensions a la Matlab\n\"\"\"\n\nfrom __future__ import division, print_function\n\nimport numpy as np\n\n__all__ = [\"eps\", \"db\", \"cplxpair\", \"shiftdim\"]\n\n\ndef eps(x=1.):\n    \"\"\"Provide floating point relative accuracy\n\n    This function tries to replicate the ``eps`` interface of Matlab.\n\n    Parameters\n    ----------\n    x : float or array_like or numeric type\n\n    Returns\n    -------\n    d : float or array_like\n        If x is a float, the positive distance from abs(x) to the next larger\n        in magnitude floating point number of the same precision as x.\n\n        If x is an array, operation is elementwise.\n\n        If x is a numeric type, operation is for 1.0 in that numeric type.\n\n    Examples\n    --------\n    >>> eps()\n    2.2204460492503131e-16\n    >>> eps(1/2)\n    1.1102230246251565e-16\n    >>> eps(np.float32)\n    1.1920929e-07\n    \"\"\"\n\n    def _eps(xi):\n        return np.finfo(xi).eps * np.abs(xi)\n    if isinstance(x, (type, np.dtype)):\n        return np.finfo(x).eps\n    elif np.isscalar(x):\n        return _eps(x)\n    x = np.asarray(x)\n    d = np.empty_like(x)\n    d.flat = [_eps(xi) for xi in x.flat]\n    return d\n\n\ndef db(x, signal_type='voltage', R=1):\n    \"\"\"\n    Converts a value to dB a la Matlab\n\n    This function tries to replicate the ``dB`` interface of Matlab.\n\n    Parameters\n    ----------\n    x : real\n        value to be converted. Should be positive and non null.\n    signal_type : string, optional\n        either 'voltage' or 'power'. Defaults to 'voltage'\n    R : real, optional\n        load resistance value. Defaults to 1.\n\n    Returns\n    -------\n    y : real\n        value in dB corresponding to x\n        if signal_type is 'power' the result is 10*log10(x). Otherwise (if\n        signal_type is 'voltage'), then power is measured over resistor R\n\n    Notes\n    -----\n    The default R value assures that when signal_type is 'voltage' dB defaults\n    to the classical 20*log10(x) computation.\n    \"\"\"\n    if signal_type == 'power':\n        return 10*np.log10(x)\n    else:\n        return 10*np.log10(np.abs(x)**2./R)\n\n\ndef shiftdim(x, n=None, nargout=2):\n    \"\"\"\n    Shift dimensions a la Matlab\n\n    When n is provided, shiftdim shifts the axes of x by n.\n    If n is positive, it shifts the axes to the left, wrapping the\n    leading axes with non unitary length to the end.\n    When n is negative, it shifts the axes to the right, inserting n leading\n    axes with unitary length.\n    When n is not provided or None, it shifts the axes to the left, reducing\n    the number of dimensions and removing all the leading axes with unitary\n    length.\n\n    Parameters\n    ----------\n    x : array like\n        multi-dimensional array to operate upon\n    n : int or None, optional\n        amount to shift. Defaults to None, which means automatic computation\n    nargout : int\n        number of output values\n\n    Returns\n    -------\n    y : ndarray\n        the result of the axes shift operation\n    n : int\n        the actual shift\n\n    Examples\n    --------\n    >>> from numpy.random import rand\n    >>> a = rand(1, 1, 3, 1, 2)\n    >>> b, n = shiftdim(a)\n    >>> b.shape\n    (3, 1, 2)\n    >>> n\n    2\n    >>> c = shiftdim(b, -n, nargout=1)\n    >>> np.alltrue(c == a)\n    True\n    >>> d = shiftdim(a, 3, nargout=1)\n    >>> d.shape\n    (1, 2, 1, 1, 3)\n\n    >>> b, n = shiftdim([[[1]]])\n    >>> b, n\n    (array([[[1]]]), 0)\n    \"\"\"\n    outsel = slice(nargout) if nargout > 1 else 0\n    x = np.asarray(x)\n    s = x.shape\n    m = next((i for i, v in enumerate(s) if v > 1), 0)\n    if n is None:\n        n = m\n    if n > 0:\n        n = n % x.ndim\n    if n > 0:\n        if n <= m:\n            x = x.reshape(s[n:])\n        else:\n            x = x.transpose(np.roll(range(x.ndim), -n))\n    elif n < 0:\n            x = x.reshape((1,)*(-n)+x.shape)\n    return (x, n)[outsel]\n\n\ndef cplxpair(x, tol=None, dim=None):\n    \"\"\"\n    Sorts values into complex pairs a la Matlab.\n\n    The function takes a vector or multidimensional array of of complex\n    conjugate pairs or real numbers and rearranges it so that the complex\n    numbers are collected into matched pairs of complex conjugates. The pairs\n    are ordered by increasing real part, with purely real elements placed\n    after all the complex pairs.\n\n    In the search for complex conjugate pairs a relative tolerance equal to\n    ``tol`` is used for comparison purposes. The default tolerance is\n    100 times the system floating point accuracy.\n\n    If the input vector is a multidimensional array, the rearrangement is done\n    working along the axis specifid by the parameter ``dim`` or along the\n    first axis with non-unitary length if ``dim`` is not provided.\n\n    Parameters\n    ----------\n    x : array_like of complex\n        x is an array of complex values, with the assumption that it contains\n        either real values or complex values in conjugate pairs.\n    tol: real, optional\n        relative tolerance for the recognition of pairs.\n        Defaults to 100 times the system floating point accuracy for the\n        specific number type.\n    dim: integer, optional\n        The axis to operate upon.\n\n    Returns\n    -------\n    y : ndarray\n        y is an array of complex values, with the same values in x, yet now\n        sorted as complex pairs by increasing real part. Real elements in x\n        are place after the complex pairs, sorted in increasing order.\n\n    Raises\n    ------\n    ValueError\n        'Complex numbers cannot be paired' if there are unpaired complex\n        entries in x.\n\n    Examples\n    --------\n    >>> a = np.exp(2j*np.pi*np.arange(0, 5)/5)\n    >>> b1 = cplxpair(a)\n    >>> b2 = np.asarray([-0.80901699-0.58778525j, -0.80901699+0.58778525j,\n    ...                   0.30901699-0.95105652j,  0.30901699+0.95105652j,\n    ...                   1.00000000+0.j])\n    >>> np.allclose(b1, b2)\n    True\n\n    >>> cplxpair(1)\n    array([1])\n\n    >>> cplxpair([[5, 6, 4], [3, 2, 1]])\n    array([[3, 2, 1],\n           [5, 6, 4]])\n\n    >>> cplxpair([[5, 6, 4], [3, 2, 1]], dim=1)\n    array([[4, 5, 6],\n           [1, 2, 3]])\n\n    See also\n    --------\n    eps : the system floating point accuracy\n    \"\"\"\n\n    def cplxpair_vec(x, tol):\n        real_mask = np.abs(x.imag) <= tol*np.abs(x)\n        x_real = np.sort(np.real(x[real_mask]))\n        x_cplx = np.sort(x[np.logical_not(real_mask)])\n        if x_cplx.size == 0:\n            return x_real\n        if (x_cplx.size % 2) != 0:\n            raise ValueError('Complex numbers cannot be paired')\n        if np.any(np.real(x_cplx[1::2])-np.real(x_cplx[0::2]) >\n                  tol*np.abs(x_cplx[0::2])):\n            raise ValueError('Complex numbers cannot be paired')\n        start = 0\n        while start < x_cplx.size:\n            sim_len = next((i for i, v in enumerate(x_cplx[start+1:]) if\n                           (np.abs(np.real(v)-np.real(x_cplx[start])) >\n                            tol*np.abs(v))), x_cplx.size-start-1)+1\n            if (sim_len % 2) != 0:\n                sim_len -= 1\n            # At this point, sim_len elements with identical real part\n            # have been identified.\n            sub_x = x_cplx[start:start+sim_len]\n            srt = np.argsort(np.imag(sub_x))\n            sub_x = sub_x[srt]\n            if np.any(np.abs(np.imag(sub_x)+np.imag(sub_x[::-1])) >\n                      tol*np.abs(sub_x)):\n                raise ValueError('Complex numbers cannot be paired')\n            # Output should contain \"perfect\" pairs. Hence, keep entries\n            # with positive imaginary parts amd use conjugate for pair\n            x_cplx[start:start+sim_len] = np.concatenate(\n                (np.conj(sub_x[:sim_len//2-1:-1]),\n                 sub_x[:sim_len//2-1:-1]))\n            start += sim_len\n        return np.concatenate((x_cplx, x_real))\n\n    x = np.atleast_1d(x)\n    if x.size == 0:\n        return x\n    if dim is None:\n        dim = next((i for i, v in enumerate(x.shape) if v > 1), 0)\n    if tol is None:\n        try:\n            tol = 100*eps(x.dtype)\n        except:\n            tol = 100*eps(np.float)\n    return np.apply_along_axis(cplxpair_vec, dim, x, tol)\n", "meta": {"hexsha": "419255d267339ddabf822d5aad7d15bc3f3fffed", "size": 9277, "ext": "py", "lang": "Python", "max_stars_repo_path": "pydsm/relab.py", "max_stars_repo_name": "EnjoyLifeFund/macHighSierra-py36-pkgs", "max_stars_repo_head_hexsha": "5668b5785296b314ea1321057420bcd077dba9ea", "max_stars_repo_licenses": ["BSD-3-Clause", "BSD-2-Clause", "MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pydsm/relab.py", "max_issues_repo_name": "EnjoyLifeFund/macHighSierra-py36-pkgs", "max_issues_repo_head_hexsha": "5668b5785296b314ea1321057420bcd077dba9ea", "max_issues_repo_licenses": ["BSD-3-Clause", "BSD-2-Clause", "MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pydsm/relab.py", "max_forks_repo_name": "EnjoyLifeFund/macHighSierra-py36-pkgs", "max_forks_repo_head_hexsha": "5668b5785296b314ea1321057420bcd077dba9ea", "max_forks_repo_licenses": ["BSD-3-Clause", "BSD-2-Clause", "MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.4163934426, "max_line_length": 78, "alphanum_fraction": 0.5926484855, "include": true, "reason": "import numpy,from numpy", "num_tokens": 2490, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49609382947091946, "lm_q2_score": 0.10230470583990364, "lm_q1q2_score": 0.05075273329301373}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Quant Analyst Intern Assessment\n# \n# ## Section #2: Multivariate Time Series Analysis\n# \n# ### In this section, you will build a Multivariate Time Series Model. Please use Jupyter Notebook for this exercise. You may answer all questions in MARKDOWN inside the Jupyter Notebook.\n\n# \n# ### a. Propose up to five factors that may affect the USD/CAD trading range and explain your reasons for making these assumptions. Also explain the type of data frequency you will use (for example, intraday 5 minutes/daily/weekly).\n# \n# *I choose the following four factors:\n# WTI crude oil price, xauusd, U.S. retail sales year-on-year, U.S. crude oil exports to Canada.*\n# \n# *I think there are not many factors that affect USD/CAD. It is mainly considered from the oil price data and U.S. economic data.*\n# \n# *First of all, the Canadian dollar is a commodity currency. Canada’s economic orientation is also dominated by exports. It is one of the important oil exporting countries. Therefore, rising oil prices may put a lot of pressure on the Canadian dollar. At this time, its purchasing power is limited. It will be greatly reduced, and it will depreciate against major currencies. It should be noted that although Canada exports a lot of oil, it also imports a lot of oil from the United States. A considerable part of this is that Canada first exported crude oil to the United States, then import it back from the United States. So I chose the WTI crude oil price and the amount of crude oil exported from the U.S. to Canada.*\n# \n# *Secondly, US consumption data, QE, Taper, and fiscal policies will all have an impact on usd/cad. Gold is closely related to the US dollar, so I chose xauusd. Since consumption accounts for a large proportion of the US economy, so from the perspective of consumption data I chose the retail sales year-on-year, and similarly, I can also choose the consumer confidence index instead. Here is a detail, the poor employment data of the United States will drive the Canadian dollar to rise, because the United States is full of employment, and the production of shale oil also increases, the oil prices fall.*\n# \n# *The specific choice actually depends on the strategy in different periods. For example, the current international oil prices are rising, but Canadian export oil is selling well, causing usdcad to fall a lot. If the U.S. dollar taper, international oil prices are weak, OPEC increases production capacity, and the U.S. dollar appreciates, the Canadian dollar will weaken relatively, and the logic will become dependent on US consumption data and manufacturing data.*\n# \n# *In the actual trading strategy, the higher the data frequency, the better. The FX leverage ratio is very high, so it is trading back and forth in the min range, and no one can bear the fluctuation of the next day.*\n# \n# *And I think the best construction of this model should be based on the long-term trend of the U.S. dollar index and the long-term trend of international oil prices, to build a large-scale model of usdcad, and build it with mathematical data from a macro perspective. There is a dual relationship between the surface and the inside called the trend structure in technical theory, that is, any trend in a large level must fall in a certain direction. The long-term trend is the general direction, and the time series modeling can be better in the changing market to capture the high and low points of our trading, so it will be more useful in higher frequency transactions.*\n# \n# *However, due to the limited frequency and range of data I can obtain, and in order to simplify the model, the data selected below are all daily frequencies.*\n\n# ### b.\tCausality & Statistical Signifiance \n# \n#    i. Utilize the Granger’s Causality Test to test foe causation in the variables that you have selected. Construct a matrix to show the p-values of the variables against one another (i.e., you also need to show that there are possible relationships between one another; not just USD/CAD).   \n# \n#    ii. [Test for Statistical Significance Between Time Series] Use the Johassen’s test of cointegration to check statistical significance in your variables. \n# \n# ### c.\t[Check for Stationarity] Implement an ADF test to check for stationarity. If it is not stationary, conduct a first-order differencing and re-check for stationarity. Show the ADF p-values for all the selected variables. If first-order differencing is not stationary, conduct a second-order differencing and re-run the ADF test.\n# \n# ### d.\t[Model Selection] Using fit comparison estimates of AIC, BIC, FPE, and HQIC. Using the Fit comparison estimates to derive the most optimal number of lags for the model.\n# \n\n# ### Data Preprocessing\n# \n\n# In[1]:\n\n\n# Data Preprocessing\n\nimport numpy as np\nimport pandas as pd\nfrom datetime import datetime\nimport matplotlib.pyplot as plt\n\ndef Interpolation(data_process):\n    \n    \"\"\"\n    Interpolation\n\n    Perform arithmetic interpolation on the missing values of a column of data\n    \"\"\"\n    \n    j = 0\n    df_seq = []\n    df = data_process.values\n    \n    # arithmetic interpolation, the value of 0 is also considered here.\n    for i in range(len(df)):\n        if df[i] != 0:\n            diff = (df[i]-df[j])/(i-j)\n            data_arange = np.arange(df[j], df[i], diff)\n            j = i\n            for num in range(len(data_arange)):\n                df_seq.append(data_arange[num])\n                \n        #if i == len(df)-1 and df[i] != 0:\n        #    df_seq.append(df[i])\n        \n        if i == len(df)-1 and df[i] == 0:\n            end = df[j] + diff * (i-j)\n            data_arange = np.arange(df[j], end, diff)\n            for num in range(len(data_arange)):\n                df_seq.append(data_arange[num])\n            if len(df_seq) != len(df):\n                df_seq.append(end)\n                      \n    return df_seq\n\n\ndata = pd.read_csv('./HistoryData.csv')  # Read data.\n\ndata['Date'] = pd.to_datetime(data['Date'])\ndata.index = data['Date']  # Convert date format\n\n# data.info()\n\ndata['WTI'] = data['WTI'].bfill() # There are few missing values in wti, so only mean interpolation is used.\n\ndata = data.fillna(0)\n\n# These two are monthly data, and its trend needs to be retained, so use arithmetic interpolation\ndata['Sales_Rate'] = Interpolation(data['Sales_Rate'])\ndata['CrudeOilExports_UStoCanada'] = Interpolation(data['CrudeOilExports_UStoCanada'])\ndata = data.drop(data[(data['Sales_Rate']==0) |(data['CrudeOilExports_UStoCanada']==0)].index)\n\ndata.to_csv('./train_data.csv', index = False, header = True)\ndata.describe()\n\n\n# In[4]:\n\n\n# Data Visualization\nDailyWTI = plt.figure(figsize = (10, 4))\nax = DailyWTI.add_subplot(111)\nax.set(title = 'WTI_DailyData',\n        ylabel = 'Price', xlabel='Date')\n\nplt.plot(data['Date'], data['WTI'])\nplt.show()    \n\nDailyXAU_USD = plt.figure(figsize = (10, 4))\nax = DailyXAU_USD.add_subplot(111)\nax.set(title = 'XAU_USD_DailyData',\n        ylabel = 'Price', xlabel='Date')\n\nplt.plot(data['Date'], data['XAU_USD'])\nplt.show() \n\nDailySales_Rate = plt.figure(figsize = (10, 4))\nax = DailySales_Rate.add_subplot(111)\nax.set(title = 'Sales_Rate_DailyData',\n        ylabel = 'Price', xlabel='Date')\n\nplt.plot(data['Date'], data['Sales_Rate'])\nplt.show()    \n\nDailyCrudeOilExports_UStoCanada = plt.figure(figsize = (10, 4))\nax = DailyCrudeOilExports_UStoCanada.add_subplot(111)\nax.set(title = 'CrudeOilExports_UStoCanada_DailyData',\n        ylabel = 'Price', xlabel='Date')\n\nplt.plot(data['Date'], data['CrudeOilExports_UStoCanada'])\nplt.show() \n\n\n# ### Granger Causality Tests\n# \n# ##### if p is less than 0.05, Granger causality is considered\n\n# In[5]:\n\n\ndef Grangercausalitytests(data, maxlag_num):\n    \n    \"\"\"\n    Granger Causality Tests\n\n    if p is less than 0.05, Granger causality is considered\n    \"\"\"\n    \n    from statsmodels.tsa.stattools import grangercausalitytests\n    grangercausalitytests(data, maxlag=maxlag_num)\n\n    \n# All variables need to be tested\nprint('Grangercausalitytests Result between WTI and USD_CAD')\nGrangercausalitytests(data[['WTI', 'USD_CAD']], 3)\n      \nprint('\\nGrangercausalitytests Result between XAU_USD and USD_CAD')\nGrangercausalitytests(data[['XAU_USD', 'USD_CAD']], 3)\n\nprint('\\nGrangercausalitytests Result between Sales_Rate and USD_CAD')\nGrangercausalitytests(data[['Sales_Rate', 'USD_CAD']], 3)\n      \nprint('\\nGrangercausalitytests Result between CrudeOilExports_UStoCanada and USD_CAD')\nGrangercausalitytests(data[['CrudeOilExports_UStoCanada', 'USD_CAD']], 3)\n\n\nprint('\\nGrangercausalitytests Result between WTI and CrudeOilExports_UStoCanada')\nGrangercausalitytests(data[['WTI', 'CrudeOilExports_UStoCanada']], 3)\n      \nprint('\\nGrangercausalitytests Result between Sales_Rate and CrudeOilExports_UStoCanada')\nGrangercausalitytests(data[['Sales_Rate', 'CrudeOilExports_UStoCanada']], 3)\n      \nprint('\\nGrangercausalitytests Result between XAU_USD and CrudeOilExports_UStoCanada')\nGrangercausalitytests(data[['XAU_USD', 'CrudeOilExports_UStoCanada']], 3)\n\n\nprint('\\nGrangercausalitytests Result between WTI and Sales_Rate')\nGrangercausalitytests(data[['WTI', 'Sales_Rate']], 3)\n      \nprint('\\nGrangercausalitytests Result between XAU_USD and Sales_Rate')\nGrangercausalitytests(data[['XAU_USD', 'Sales_Rate']], 3)\n\n\nprint('\\nGrangercausalitytests Result between WTI and XAU_USD')\nGrangercausalitytests(data[['WTI', 'XAU_USD']], 3)\n\n\n# ### ADF: Augmented Dickey-Fuller Unit Root  Tests\n# \n# ##### Check if it is a stationary series\n\n# In[6]:\n\n\ndef ADF_diff(timeseries, name):\n    \n    \"\"\"\n    ADF: Augmented Dickey-Fuller unit root test.\n    \n    Regression: Constant and trend order to include {“c”,”ct”,”ctt”,”nc”}\n    1. “c” : constant only (default).\n    2. “ct” : constant and trend.\n    3. “ctt” : constant, and linear and quadratic trend.\n    4. “nc” : no constant, no trend.\n    \"\"\"\n\n    import pandas as pd\n    import statsmodels.api as sm\n    import matplotlib.pyplot as plt\n    from statsmodels.tsa.stattools import adfuller as ADF\n    \n    # Sequence after generating the differencing.\n    timeseries_diff1 = timeseries.diff(1)\n    timeseries_diff2 = timeseries_diff1.diff(1)\n\n    timeseries_diff1 = timeseries_diff1.fillna(0)\n    timeseries_diff2 = timeseries_diff2.fillna(0)\n\n    # ADF unit root test -- ct\n    print('Result of ADF--ct Test ')\n    timeseries_adf = ADF(timeseries[name].tolist(), regression='ct')\n    timeseries_diff1_adf = ADF(timeseries_diff1[name].tolist(), regression='ct')\n    timeseries_diff2_adf = ADF(timeseries_diff2[name].tolist(), regression='ct')\n\n    print('timeseries_adf : ', timeseries_adf)\n    print('timeseries_diff1_adf : ', timeseries_diff1_adf)\n    print('timeseries_diff2_adf : ', timeseries_diff2_adf)\n\n    plt.figure(figsize=(12, 8))\n    plt.plot(timeseries, label='Original', color='blue')\n    plt.plot(timeseries_diff1, label='Diff1', color='red')\n    plt.plot(timeseries_diff2, label='Diff2', color='purple')\n    plt.legend(loc='best')\n    plt.show()\n    \n    # ADF unit root test -- c\n    print('Result of ADF--c Test ')\n    timeseries_adf = ADF(timeseries[name].tolist(), regression='c')\n    timeseries_diff1_adf = ADF(timeseries_diff1[name].tolist(), regression='c')\n    timeseries_diff2_adf = ADF(timeseries_diff2[name].tolist(), regression='c')\n\n    print('timeseries_adf : ', timeseries_adf)\n    print('timeseries_diff1_adf : ', timeseries_diff1_adf)\n    print('timeseries_diff2_adf : ', timeseries_diff2_adf)\n\n    plt.figure(figsize=(12, 8))\n    plt.plot(timeseries, label='Original', color='blue')\n    plt.plot(timeseries_diff1, label='Diff1', color='red')\n    plt.plot(timeseries_diff2, label='Diff2', color='purple')\n    plt.legend(loc='best')\n    plt.show()\n    \n    # ADF unit root test -- nc\n    print('Result of ADF--nc Test ')\n    timeseries_adf = ADF(timeseries[name].tolist(), regression='nc')\n    timeseries_diff1_adf = ADF(timeseries_diff1[name].tolist(), regression='nc')\n    timeseries_diff2_adf = ADF(timeseries_diff2[name].tolist(), regression='nc')\n\n    print('timeseries_adf : ', timeseries_adf)\n    print('timeseries_diff1_adf : ', timeseries_diff1_adf)\n    print('timeseries_diff2_adf : ', timeseries_diff2_adf)\n\n    plt.figure(figsize=(12, 8))\n    plt.plot(timeseries, label='Original', color='blue')\n    plt.plot(timeseries_diff1, label='Diff1', color='red')\n    plt.plot(timeseries_diff2, label='Diff2', color='purple')\n    plt.legend(loc='best')\n    plt.show()\n\n# Parse data with date for training   \ndateparse = lambda dates: datetime.strptime(dates, '%Y-%m-%d')\ntrain_data = pd.read_csv('./train_data.csv', parse_dates=['Date'],\n                                 index_col='Date', date_parser=dateparse)\n\n# Extract the data of each variable for future use\ndata_WTI = pd.DataFrame(train_data['WTI'])\ndata_XAU_USD = pd.DataFrame(train_data['XAU_USD'])\ndata_Sales_Rate = pd.DataFrame(train_data['Sales_Rate'])\ndata_CrudeOilExports_UStoCanada = pd.DataFrame(train_data['CrudeOilExports_UStoCanada'])\ndata_USD_CAD = pd.DataFrame(train_data['USD_CAD'])\n\n# ADF Tests\nprint(\"Resulty of ADF -- WTI\")\nADF_diff(data_WTI, 'WTI')\nprint(\"Resulty of ADF -- XAU_USD\")\nADF_diff(data_XAU_USD, 'XAU_USD')\nprint(\"Resulty of ADF -- Sales_Rate\")\nADF_diff(data_Sales_Rate, 'Sales_Rate')\nprint(\"Resulty of ADF -- CrudeOilExports_UStoCanada\")\nADF_diff(data_CrudeOilExports_UStoCanada, 'CrudeOilExports_UStoCanada')\nprint(\"Resulty of ADF -- USD_CAD\")\nADF_diff(data_USD_CAD, 'USD_CAD')\n\n\n# ### Fit Comparison Estimates of AIC, BIC, FPE, and HQIC.\n# \n# ##### Using fit comparison estimates of AIC, BIC, FPE, and HQIC. \n# ##### Using the Fit comparison estimates to derive the most optimal number of lags for the model.\n\n# In[7]:\n\n\ndef order_selection(timeseries):\n    \n    \"\"\"\n    Select the optimal lag order.\n    \n    Use Vector Auto Regression (VAR) Model to select order.\n    The var model can pass a maximum number of lags and the order criterion to use for lag order selection.\n    \"\"\"\n    \n    import statsmodels.api as sm\n    from statsmodels.tsa.api import VAR\n    \n    # Vector Auto Regression (VAR) Model\n    var_model = VAR(timeseries)\n\n    #Lag order selection\n    order = var_model.select_order(10)\n    print(order.summary())\n    \n    #var_results = var_model.fit(maxlags=5, ic='aic')\n    #var_results.summary()\n\n\n# Use original data to select order\norder_selection(train_data)\n\n# data after differencing\ntrain_data_diff = train_data\n\ndata_WTI_diff1 = data_WTI.diff(1)\ndata_WTI_diff1 = data_WTI_diff1.fillna(0)\ntrain_data_diff['WTI'] = data_WTI_diff1\n\ndata_XAU_USD_diff1 = data_XAU_USD.diff(1)\ndata_XAU_USD_diff1 = data_XAU_USD_diff1.fillna(0)\ntrain_data_diff['XAU_USD'] = data_XAU_USD_diff1\n\ndata_Sales_Rate_diff1 = data_Sales_Rate.diff(1)\ndata_Sales_Rate_diff2 = data_Sales_Rate_diff1.diff(1)\ndata_Sales_Rate_diff2 = data_Sales_Rate_diff2.fillna(0)\ntrain_data_diff['Sales_Rate'] = data_Sales_Rate_diff2\n\ndata_CrudeOilExports_UStoCanada_diff1 = data_CrudeOilExports_UStoCanada.diff(1)\ndata_CrudeOilExports_UStoCanada_diff2 = data_CrudeOilExports_UStoCanada_diff1.diff(1)\ndata_CrudeOilExports_UStoCanada_diff2 = data_CrudeOilExports_UStoCanada_diff2.fillna(0)\ntrain_data_diff['CrudeOilExports_UStoCanada'] = data_CrudeOilExports_UStoCanada_diff2\n\ndata_USD_CAD_diff1 = data_USD_CAD.diff(1)\ndata_USD_CAD_diff1 = data_USD_CAD_diff1.fillna(0)\ntrain_data_diff['USD_CAD'] = data_USD_CAD_diff1\n\n# Use data after differencing to select order\norder_selection(train_data_diff)\n\n\n# ### Johassen’s test of cointegration\n\n# In[8]:\n\n\ndef coint_johansen(timeseries):\n    \n    \"\"\"\n    Johassen’s test of cointegration\n    \n    Use the Johassen’s test of cointegration to check statistical significance in your variables. \n    \"\"\"\n    \n    from statsmodels.tsa.vector_ar import vecm\n    \n    # Johansen cointegration test, situation setting = continuous features\n    jres1 = vecm.coint_johansen(timeseries, det_order=0, k_ar_diff=1)\n\n    # View johansen cointegration test results\n    johansen_result = vecm.select_coint_rank(timeseries,det_order=0, k_ar_diff=1, signif=0.1)\n    print(johansen_result.summary())\n\n    # Choice of rank\n    print(johansen_result.rank)\n\n    j_name=np.array([['Order'], ['trace statistics'], ['CV 90%'],  ['CV 95%'], ['CV 99%'] ] )\n    print(j_name)\n    \n    j_order = jres1.ind \n    print(j_order) # Order of eigenvalues \n    \n    j_lr1 = jres1.lr1 \n    print(j_lr1) # trace statistics\n    \n    j_cvt = jres1.cvt \n    print(j_cvt) # Critical values (90%, 95%, 99%) of trace statistic\n\n    # j_result = np.vstack(( j_order,  j_lr1, j_cvt))\n    # print(j_result)\n\n    pd.DataFrame(jres1.r0t).plot(kind='bar')  # Residuals for Δ\n    \n    \ncoint_johansen(train_data_diff)\n\n\n# ### e.\t[Forecast] Utilizing your model, forecast the daily close for the next five days, include a 75% confidence interval. Derive the USD/CAD closing price range for the next 5 days (i.e., Min & Max).\n# \n\n# ### VECM Model\n\n# In[346]:\n\n\n# Use VECM Model to Forecast\nmod = vecm.VECM(train_data_diff, k_ar_diff=1, coint_rank=5, freq='B', deterministic=\"ci\")\nres = mod.fit()\nprint(res.summary())\n\n\n# In[347]:\n\n\n\"\"\"\nNotes:\n\nforecast - ndarray (steps x neqs) or three ndarrays\n\nIn case of a point forecast: each row of the returned ndarray represents the forecast of the neqs variables for a specific period. \nThe first row (index [0]) is the forecast for the next period, the last row (index [steps-1]) is the steps-periods-ahead- forecast.\n\"\"\"\n\n# An image of data that predicts one step forward (showing confidence interval, confidence interval 75%)\nres.plot_forecast(steps=5,plot_conf_int=True,alpha=0.75)\n\n# Predict the value one step forward, with 75% confidence\nres.predict(steps=5, alpha=0.75)\n\n\n# In[ ]:\n\n\n\n\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "4b1e092007addffd5f99ad0f82dfec7c9edae152", "size": 17666, "ext": "py", "lang": "Python", "max_stars_repo_path": "USD_CAD_Prediction/Sec2.py", "max_stars_repo_name": "Anna-Huang1/ExerciseProjects", "max_stars_repo_head_hexsha": "aadf31de043f5f7631e81dadec31ee9800dcf13a", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "USD_CAD_Prediction/Sec2.py", "max_issues_repo_name": "Anna-Huang1/ExerciseProjects", "max_issues_repo_head_hexsha": "aadf31de043f5f7631e81dadec31ee9800dcf13a", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "USD_CAD_Prediction/Sec2.py", "max_forks_repo_name": "Anna-Huang1/ExerciseProjects", "max_forks_repo_head_hexsha": "aadf31de043f5f7631e81dadec31ee9800dcf13a", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.4043478261, "max_line_length": 723, "alphanum_fraction": 0.7222348013, "include": true, "reason": "import numpy,import statsmodels,from statsmodels", "num_tokens": 4727, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3380771374883919, "lm_q2_score": 0.1500288186418291, "lm_q1q2_score": 0.05072131354719467}}
{"text": "# Copyright 2019 Xanadu Quantum Technologies Inc.\n\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n\n#     http://www.apache.org/licenses/LICENSE-2.0\n\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nr\"\"\"\nPython library\n==============\n\n.. currentmodule:: thewalrus\n\nThis is the top level module of the The Walrus Python interface,\ncontaining functions for computing the hafnian, loop hafnian,\nand torontonian of matrices.\n\nAlgorithm terminology\n---------------------\n\nEigenvalue hafnian algorithm\n    The algorithm described in\n    *A faster hafnian formula for complex matrices and its benchmarking on a supercomputer*,\n    :cite:`bjorklund2018faster`.\n    This algorithm scales like :math:`\\mathcal{O}(n^3 2^{n/2})`, and supports calculation of\n    the loop hafnian.\n\nRecursive hafnian algorithm\n    The algorithm described in *Counting perfect matchings as fast as Ryser* :cite:`bjorklund2012counting`.\n    This algorithm scales like :math:`\\mathcal{O}(n^4 2^{n/2})`. This algorithm does not\n    currently support the loop hafnian.\n\nRepeating hafnian algorithm\n    The algorithm described in *From moments of sum to moments of product*, :cite:`kan2008moments`.\n    This method is more efficient for matrices with repeated rows and columns, and supports caclulation of\n    the loop hafnian.\n\nApproximate hafnian algorithm\n    The algorithm described in *Polynomial time algorithms to approximate permanents and mixed discriminants\n    within a simply exponential factor*, :cite:`barvinok1999polynomial`.\n    This algorithm allows us to efficiently approximate the hafnian of\n    matrices with non-negative elements. This is done by sampling determinants;\n    the larger the number of samples taken, the higher the accuracy.\n\nBatched hafnian algorithm\n    An algorithm that allows the calculation of hafnians of all reductions of\n    a given matrix up to the cutoff (resolution) provided. Internally, this algorithm\n    makes use of the multidimensional Hermite polynomials as per\n    *The calculation of multidimensional Hermite polynomials and Gram-Charlier coefficients*\n    :cite:`berkowitz1970calculation`.\n\nLow-rank hafnian algorithm\n    An algorithm that allows to calculate the hafnian of an :math:`r`-rank matrix :math:`\\bm{A}` of size :math:`n \\times n`\n    by factorizing it as :math:`\\bm{A} = \\bm{G} \\bm{G}^T` where :math:`\\bm{G}` is of size :math:`n \\times r`. The algorithm\n    is described in Appendix C of\n    *A faster hafnian formula for complex matrices and its benchmarking on a supercomputer*,\n    :cite:`bjorklund2018faster`.\n\n\nPython wrappers\n---------------\n\n.. autosummary::\n    hafnian\n    hafnian_repeated\n    hafnian_batched\n    tor\n    perm\n    permanent_repeated\n    hermite_multidimensional\n\nPure Python functions\n---------------------\n\n.. autosummary::\n    reduction\n    version\n    low_rank_hafnian\n\"\"\"\n# pylint: disable=wrong-import-position\nimport os\nimport platform\n\nimport numpy as np\n\nimport thewalrus.quantum\n\nfrom ._hafnian import (\n    haf_complex,\n    haf_int,\n    haf_real,\n    haf_rpt_complex,\n    haf_rpt_real,\n    hafnian,\n    hafnian_repeated,\n    reduction,\n)\nfrom ._low_rank_haf import low_rank_hafnian\nfrom ._hermite_multidimensional import hafnian_batched, hermite_multidimensional\nfrom ._permanent import perm, perm_complex, perm_real, permanent_repeated\nfrom ._torontonian import tor, threshold_detection_prob_displacement, threshold_detection_prob, numba_tor\nfrom ._version import __version__\n\n\n__all__ = [\n    \"hafnian\",\n    \"hafnian_repeated\",\n    \"hafnian_batched\",\n    \"tor\",\n    \"perm\",\n    \"permanent_repeated\",\n    \"reduction\",\n    \"hermite_multidimensional\",\n    \"version\",\n]\n\n\ndef version():\n    r\"\"\"\n    Get version number of The Walrus\n\n    Returns:\n      str: The package version number\n    \"\"\"\n    return __version__\n", "meta": {"hexsha": "b445f56f86badd2b9cb1b2251e3ac8594a12f805", "size": 4178, "ext": "py", "lang": "Python", "max_stars_repo_path": "thewalrus/__init__.py", "max_stars_repo_name": "jakeffbulmer/thewalrus", "max_stars_repo_head_hexsha": "c0da9359f6f118ebdde3cf08f899e7f4d21d9f0b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "thewalrus/__init__.py", "max_issues_repo_name": "jakeffbulmer/thewalrus", "max_issues_repo_head_hexsha": "c0da9359f6f118ebdde3cf08f899e7f4d21d9f0b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "thewalrus/__init__.py", "max_forks_repo_name": "jakeffbulmer/thewalrus", "max_forks_repo_head_hexsha": "c0da9359f6f118ebdde3cf08f899e7f4d21d9f0b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.6515151515, "max_line_length": 123, "alphanum_fraction": 0.7386309239, "include": true, "reason": "import numpy", "num_tokens": 1065, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.480478678047907, "lm_q2_score": 0.10521052968901465, "lm_q1q2_score": 0.05055141622169783}}
{"text": "__author__ = 'Robert Meyer'\n\nimport numpy as np\nimport inspect\nimport os # For path names being viable under Windows and Linux\n\nfrom pypet import Environment, Parameter, ArrayParameter, Trajectory\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n\n\n# Here we will see how we can write our own custom parameters and how we can use\n# it with a trajectory.\n\n# Now we want to do a more sophisticated simulations, we will integrate a differential equation\n# with an Euler scheme\n\n# Let's first define our job to do\ndef euler_scheme(traj, diff_func):\n    \"\"\"Simulation function for Euler integration.\n\n    :param traj:\n\n        Container for parameters and results\n\n    :param diff_func:\n\n        The differential equation we want to integrate\n\n    \"\"\"\n\n    steps = traj.steps\n    initial_conditions = traj.initial_conditions\n    dimension = len(initial_conditions)\n\n    # This array will collect the results\n    result_array = np.zeros((steps,dimension))\n    # Get the function parameters stored into `traj` as a dictionary\n    # with the (short) names as keys :\n    func_params_dict = traj.func_params.f_to_dict(short_names=True, fast_access=True)\n    # Take initial conditions as first result\n    result_array[0] = initial_conditions\n\n    # Now we compute the Euler Scheme steps-1 times\n    for idx in range(1,steps):\n        result_array[idx] = diff_func(result_array[idx-1], **func_params_dict) * traj.dt + \\\n                            result_array[idx-1]\n    # Note the **func_params_dict unzips the dictionary, it's the reverse of **kwargs in function\n    # definitions!\n\n    #Finally we want to keep the results\n    traj.f_add_result('euler_evolution', data=result_array, comment='Our time series data!')\n\n\n# Ok, now we want to make our own (derived) parameter that stores source code of python functions.\n# We do NOT want a parameter that stores an executable function. This would complicate\n# the problem a lot. If you have something like that in mind, you might wanna take a look\n# at the marshal (http://docs.python.org/2/library/marshal) module\n# or dill (https://pypi.python.org/pypi/dill) package.\n# Our intention here is to define a parameter that we later on use as a derived parameter\n# to simply keep track of the source code we use ('git' would be, of course, the better solution\n# but this is just an illustrative example)\nclass FunctionParameter(Parameter):\n    # We need to override the `f_set` function and simply extract the the source code if our\n    # item is callable and store this instead.\n    def f_set(self, data):\n        if callable(data):\n            data = inspect.getsource(data)\n        return super(FunctionParameter, self).f_set(data)\n\n    # For more complicate parameters you might consider implementing:\n    # `f_supports` (we do not need it since we convert the data to stuff the parameter already\n    #    supports, and that is strings!)\n    #\n    # and\n    # the private functions\n    #\n    # `_values_of_same_type` (to tell whether data is similar, i.e. of two data items agree in their\n    #   type, this is important to only allow exploration within the same dimension.\n    #   For instance, a parameter that stores integers, should only explore integers etc.)\n    #\n    # and\n    #\n    # `_equal_values` (to tell if two data items are equal. This is important for merging if you\n    #       want to erase duplicate parameter points. The trajectory needs to know when a\n    #       parameter space point was visited before.)\n    #\n    # and\n    #\n    # `_store` (to be able to turn complex data into basic types understood by the storage service)\n    #\n    # and\n    #\n    # `_load` (to be able to recover your complex data form the basic types understood by the storage\n    # service)\n    #\n    # But for now we will rely on the parent functions and hope for the best!\n\n\n\n# Ok now let's follow the ideas in the final section of the cookbook and let's\n# have a part in our simulation that only defines the parameters.\ndef add_parameters(traj):\n    \"\"\"Adds all necessary parameters to the `traj` container\"\"\"\n\n    traj.f_add_parameter('steps', 10000, comment='Number of time steps to simulate')\n    traj.f_add_parameter('dt', 0.01, comment='Step size')\n\n    # Here we want to add the initial conditions as an array parameter. We will simulate\n    # a 3-D differential equation, the Lorenz attractor.\n    traj.f_add_parameter(ArrayParameter,'initial_conditions', np.array([0.0,0.0,0.0]),\n                         comment = 'Our initial conditions, as default we will start from'\n                                   ' origin!')\n\n    # We will group all parameters of the Lorenz differential equation into the group 'func_params'\n    traj.f_add_parameter('func_params.sigma', 10.0)\n    traj.f_add_parameter('func_params.beta', 8.0/3.0)\n    traj.f_add_parameter('func_params.rho', 28.0)\n\n    #For the fun of it we will annotate the  group\n    traj.func_params.v_annotations.info='This group contains as default the original values chosen ' \\\n                                   'by Edward Lorenz in 1963. Check it out on wikipedia ' \\\n                                   '(https://en.wikipedia.org/wiki/Lorenz_attractor)!'\n\n\n# We need to define the lorenz function, we will assume that the value array is 3 dimensional,\n# First dimension contains the x-component, second y-component, and third the z-component\ndef diff_lorenz(value_array, sigma, beta, rho):\n    \"\"\"The Lorenz attractor differential equation\n\n    :param value_array: 3d array containing the x,y, and z component values.\n    :param sigma: Constant attractor parameter\n    :param beta: FConstant attractor parameter\n    :param rho: Constant attractor parameter\n\n    :return: 3d array of the Lorenz system evaluated at `value_array`\n\n    \"\"\"\n    diff_array = np.zeros(3)\n    diff_array[0] = sigma * (value_array[1]-value_array[0])\n    diff_array[1] = value_array[0] * (rho - value_array[2]) - value_array[1]\n    diff_array[2] = value_array[0] * value_array[1] - beta * value_array[2]\n\n    return diff_array\n\n\n# And here goes our main function\ndef main():\n\n    filename = os.path.join('hdf5', 'example_05.hdf5')\n    env = Environment(trajectory='Example_05_Euler_Integration',\n                      filename=filename,\n                      file_title='Example_05_Euler_Integration',\n                      overwrite_file=True,\n                      comment='Go for Euler!')\n\n\n    traj = env.trajectory\n    trajectory_name = traj.v_name\n\n    # 1st a) phase parameter addition\n    add_parameters(traj)\n\n    # 1st b) phase preparation\n    # We will add the differential equation (well, its source code only) as a derived parameter\n    traj.f_add_derived_parameter(FunctionParameter,'diff_eq', diff_lorenz,\n                                 comment='Source code of our equation!')\n\n    # We want to explore some initial conditions\n    traj.f_explore({'initial_conditions' : [\n        np.array([0.01,0.01,0.01]),\n        np.array([2.02,0.02,0.02]),\n        np.array([42.0,4.2,0.42])\n    ]})\n    # 3 different conditions are enough for an illustrative example\n\n    # 2nd phase let's run the experiment\n    # We pass `euler_scheme` as our top-level simulation function and\n    # the Lorenz equation 'diff_lorenz' as an additional argument\n    env.run(euler_scheme, diff_lorenz)\n\n    # We don't have a 3rd phase of post-processing here\n\n    # 4th phase analysis.\n    # I would recommend to do post-processing completely independent from the simulation,\n    # but for simplicity let's do it here.\n\n    # Let's assume that we start all over again and load the entire trajectory new.\n    # Yet, there is an error within this approach, do you spot it?\n    del traj\n    traj = Trajectory(filename=filename)\n\n    # We will only fully load parameters and derived parameters.\n    # Results will be loaded manually later on.\n    try:\n        # However, this will fail because our trajectory does not know how to\n        # build the FunctionParameter. You have seen this coming, right?\n        traj.f_load(name=trajectory_name, load_parameters=2, load_derived_parameters=2,\n                    load_results=1)\n    except ImportError as e:\n\n        print('That did\\'nt work, I am sorry: %s ' % str(e))\n\n        # Ok, let's try again but this time with adding our parameter to the imports\n        traj = Trajectory(filename=filename,\n                           dynamically_imported_classes=FunctionParameter)\n\n        # Now it works:\n        traj.f_load(name=trajectory_name, load_parameters=2, load_derived_parameters=2,\n                    load_results=1)\n\n\n    #For the fun of it, let's print the source code\n    print('\\n ---------- The source code of your function ---------- \\n %s' % traj.diff_eq)\n\n    # Let's get the exploration array:\n    initial_conditions_exploration_array = traj.f_get('initial_conditions').f_get_range()\n    # Now let's plot our simulated equations for the different initial conditions:\n    # We will iterate through the run names\n    for idx, run_name in enumerate(traj.f_get_run_names()):\n\n        #Get the result of run idx from the trajectory\n        euler_result = traj.results.f_get(run_name).euler_evolution\n        # Now we manually need to load the result. Actually the results are not so large and we\n        # could load them all at once. But for demonstration we do as if they were huge:\n        traj.f_load_item(euler_result)\n        euler_data = euler_result.data\n\n        #Plot fancy 3d plot\n        fig = plt.figure(idx)\n        ax = fig.gca(projection='3d')\n        x = euler_data[:,0]\n        y = euler_data[:,1]\n        z = euler_data[:,2]\n        ax.plot(x, y, z, label='Initial Conditions: %s' % str(initial_conditions_exploration_array[idx]))\n        plt.legend()\n        plt.show()\n\n        # Now we free the data again (because we assume its huuuuuuge):\n        del euler_data\n        euler_result.f_empty()\n\n    # You have to click through the images to stop the example_05 module!\n\n    # Finally disable logging and close all log-files\n    env.disable_logging()\n\n\nif __name__ == '__main__':\n    main()\n\n", "meta": {"hexsha": "56923452fee326587109d3ccba971afc0091cef6", "size": 10056, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/example_05_custom_parameter.py", "max_stars_repo_name": "dilawar/pypet", "max_stars_repo_head_hexsha": "98673767d1e310a36ca1dcd9fe5b0d51e496db37", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 85, "max_stars_repo_stars_event_min_datetime": "2015-01-16T11:50:40.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-26T08:15:42.000Z", "max_issues_repo_path": "examples/example_05_custom_parameter.py", "max_issues_repo_name": "sthagen/pypet", "max_issues_repo_head_hexsha": "2769c74eff55c165c9002cc67611b96b1d2377ea", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 51, "max_issues_repo_issues_event_min_datetime": "2015-01-10T14:00:12.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-11T17:42:35.000Z", "max_forks_repo_path": "examples/example_05_custom_parameter.py", "max_forks_repo_name": "sthagen/pypet", "max_forks_repo_head_hexsha": "2769c74eff55c165c9002cc67611b96b1d2377ea", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 20, "max_forks_repo_forks_event_min_datetime": "2015-01-16T11:51:15.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-26T08:15:44.000Z", "avg_line_length": 39.9047619048, "max_line_length": 105, "alphanum_fraction": 0.6832736675, "include": true, "reason": "import numpy", "num_tokens": 2345, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.10087862070270603, "lm_q1q2_score": 0.05043931035135302}}
{"text": "#!/usr/bin/env python\nu\"\"\"\ngrace_date.py\nWritten by Tyler Sutterley (05/2021)\n\nReads index file from podaac_grace_sync.py or gfz_isdc_grace_ftp.py\nParses dates of each GRACE/GRACE-FO file and assigns the month number\nCreates an index of dates for GRACE/GRACE-FO files\n\nINPUTS:\n    base_dir: Working data directory for GRACE/GRACE-FO data\n\nOPTIONS:\n    PROC: GRACE data processing center (CSR/CNES/JPL/GFZ/GRAZ/COSTG/SWARM)\n    DREL: GRACE/GRACE-FO Data Release (RL03 for CNES) (RL06 for CSR/GFZ/JPL)\n    DSET: GRACE dataset (GAA/GAB/GAC/GAD/GSM)\n        GAA is the non-tidal atmospheric correction\n        GAB is the non-tidal oceanic correction\n        GAC is the combined non-tidal atmospheric and oceanic correction\n        GAD is the GRACE ocean bottom pressure product\n        GSM is corrected monthly GRACE/GRACE-FO static field product\n    OUTPUT: create index of dates for GRACE/GRACE-FO data\n    MODE: permissions mode of output files\n\nOUTPUTS:\n    dictionary of GRACE/GRACE-FO files indexed by month\n\nPYTHON DEPENDENCIES:\n    numpy: Scientific Computing Tools For Python\n        https://numpy.org\n        https://numpy.org/doc/stable/user/numpy-for-matlab-users.html\n    dateutil: powerful extensions to datetime\n        https://dateutil.readthedocs.io/en/stable/\n    future: Compatibility layer between Python 2 and Python 3\n        https://python-future.org/\n\nPROGRAM DEPENDENCIES:\n    time.py: utilities for calculating time operations\n\nUPDATE HISTORY:\n    Updated 05/2021: define int/float precision to prevent deprecation warning\n    Updated 02/2021: use adjust_months function to fix special months cases\n    Updated 12/2020: Add SWARM data compilance\n    Updated 12/2020: using utilities from time module\n    Updated 11/2020: updated for CNES RL04 & RL05 and GRAZ 2018 (monthly fields)\n    Updated 10/2020: use argparse to set command line parameters\n    Updated 07/2020: added function docstrings\n    Updated 03/2020: for public release\n    Updated 11/2018: updated regular expression pattern for RL06 GFZ\n    Updated 08/2018: using full release string (RL05 instead of 5)\n    Updated 06/2018: using python3 compatible octal and input\n    Updated 05/2018: can read new GRACE file format for RL06 and GRACE-FO\n    Updated 10/2017: added option OUTPUT to write the text file with GRACE dates\n        now will output from the function the GRACE month and file name\n        adjusted regular expression for extracting parameters from filename\n    Updated 02/2017: added mode to modify the permissions of the output file\n    Updated 05-06/2016: using __future__ print function, format date lines\n    Updated 01/2016: minor clean up.  using enumerate for loop\n    Updated 10/2015: added manual fix for month 161 (centered in 160)\n    Updated 05/2015: additional 2 digits to date file to reduce the differences\n        in dates if importing from date file or binary data file\n    Updated 03/2015: added main definition for running from command line\n        further generalization, calculates the Julian date of the GRACE date\n    Updated 11/2014: output more decimal points for date\n    Updated 09/2014: using regular expressions, general code updates\n    Updated 03/2014: printing GRACE month with zero-padding\n    Updated 02/2014: minor update to if statements\n    Updated 01/2014: updated for CNES RL03 (monthly fields)\n    Updated 10/2013: created a directory with both RL04 and RL05 (combining)\n        made a slight edit for the drift rates\n    Updated 09/2013: changed dating schemes for all products\n        for CNES: Solution 1 == 001, versus 10-day from start of 2002\n    Updated 05/2013: modified for use with GUI program\n    Updated 07/2012: changed some variable names, and saving variables\n        start_yr, start_day, end_yr, end_day\n    Updated 07/2012: fix missing date for CSR RL05\n        One of the months 119 registered as 118 as half of 119 is in 118 due to\n        accelerometer issues during 119\n    Updated 06/2012: fixes missing dates to be automatic\n        Also added options to enter the processing center, the data release and\n        the dataset from an external main level program\n    Updated 04/2012: changes for RL05 data\n\"\"\"\nfrom __future__ import print_function\n\nimport os\nimport re\nimport argparse\nimport numpy as np\nimport gravity_toolkit.time\n\ndef grace_date(base_dir, PROC='', DREL='', DSET='', OUTPUT=True, MODE=0o775):\n    \"\"\"\n    Reads index file from podaac_grace_sync.py or gfz_isdc_grace_ftp.py\n    Parses dates of each GRACE/GRACE-FO file and assigns the month number\n    Creates an index of dates for GRACE/GRACE-FO files\n\n    Arguments\n    ---------\n    base_dir: working data directory\n\n    Keyword arguments\n    -----------------\n    PROC: GRACE data processing center\n        CSR: University of Texas Center for Space Research\n        GFZ: German Research Centre for Geosciences (GeoForschungsZentrum)\n        JPL: Jet Propulsion Laboratory\n        CNES: French Centre National D'Etudes Spatiales\n        GRAZ: Institute of Geodesy from GRAZ University of Technology\n        COSTG: International Combination Service for Time-variable Gravity Fields\n\n        SWARM: gravity data from SWARM satellite\n    DREL: GRACE/GRACE-FO data release\n    DSET: GRACE/GRACE-FO dataset\n        GAA: non-tidal atmospheric correction\n        GAB: non-tidal oceanic correction\n        GAC: combined non-tidal atmospheric and oceanic correction\n        GAD: ocean bottom pressure product\n        GSM: corrected monthly static gravity field product\n    OUTPUT: create index file of dates for GRACE/GRACE-FO data\n    MODE: Permission mode of directories and files\n\n    Returns\n    -------\n    output_files: dictionary of GRACE/GRACE-FO files indexed by month\n    \"\"\"\n\n    #--  Directory of exact product\n    grace_dir = os.path.join(base_dir, PROC, DREL, DSET)\n    #-- input index file containing GRACE data filenames\n    with open(os.path.join(grace_dir, 'index.txt'),'r') as f:\n        input_files = f.read().splitlines()\n\n    #--  number of lines in input_files\n    n_files = len(input_files)\n\n    #-- define date variables\n    start_yr = np.zeros((n_files))#-- year start date\n    end_yr = np.zeros((n_files))#-- year end date\n    start_day = np.zeros((n_files))#-- day number start date\n    end_day = np.zeros((n_files))#-- day number end date\n    mid_day = np.zeros((n_files))#-- mid-month day\n    tot_days = np.zeros((n_files))#-- number of days since Jan 2002\n    tdec = np.zeros((n_files))#-- tdec is the date in decimal form\n    mon = np.zeros((n_files,),dtype=np.int64)#-- GRACE/GRACE-FO month number\n\n    if PROC in ('CSR', 'GFZ', 'JPL', 'CNES', 'COSTG'):\n        #-- compile numerical expression operator for parameters from files\n        #-- will work with previous releases and releases for GRACE-FO\n        #-- UTCSR: The University of Texas at Austin Center for Space Research\n        #-- EIGEN: GFZ German Research Center for Geosciences (RL01-RL05)\n        #-- GFZOP: GFZ German Research Center for Geosciences (RL06+GRACE-FO)\n        #-- JPLEM: NASA Jet Propulsion Laboratory (harmonic solutions)\n        #-- JPLMSC: NASA Jet Propulsion Laboratory (mascon solutions)\n        #-- GRGS: CNES Groupe de Recherche de Géodésie Spatiale\n        regex_pattern = (r'(.*?)-2_(\\d+)-(\\d+)_(.*?)_({0})_(.*?)_(\\d+)(.*?)'\n           r'(\\.gz|\\.gfc|\\.txt)?$').format(r'UTCSR|EIGEN|GFZOP|JPLEM|JPLMSC|GRGS|COSTG')\n    elif PROC == 'GRAZ':\n        # -- GRAZ: Institute of Geodesy from GRAZ University of Technology\n        regex_pattern = (r'(.*?)-({0})_(.*?)_(\\d+)-(\\d+)'\n                         r'(\\.gz|\\.gfc|\\.txt)').format(r'Grace_operational|Grace2018')\n    elif PROC == 'SWARM':\n        # -- SWARM: data from SWARM satellite\n        regex_pattern = (r'({0})_(.*?)_(EGF_SHA_2)__(.*?)_(.*?)_(.*?)'\n                         r'(\\.gz|\\.gfc|\\.txt)').format(r'SW')\n    else:\n        raise ValueError(\"Unknown PROC value:\", PROC)\n\n    rx = re.compile(regex_pattern, re.VERBOSE)\n\n    #-- for each data file\n    for t, infile in enumerate(input_files):\n        #-- extract parameters from input filename\n        if PROC in ('CSR', 'GFZ', 'JPL', 'CNES', 'COSTG'):\n            PFX,start_date,end_date,AUX,PRC,F1,DRL,F2,SFX = rx.findall(infile).pop()\n\n            #-- find start date, end date and number of days\n            start_yr[t] = np.float64(start_date[:4])\n            end_yr[t] = np.float64(end_date[:4])\n            start_day[t] = np.float64(start_date[4:])\n            end_day[t] = np.float64(end_date[4:])\n\n        elif PROC == 'GRAZ' or PROC == 'SWARM':\n            if PROC == 'GRAZ':\n                PFX,SAT,trunc,year,month,SFX = rx.findall(infile).pop()\n                #-- find start year, end year\n                start_yr[t] = np.float(year)\n                end_yr[t] = np.float(year)\n            elif PROC == 'SWARM':\n                SAT, tmp, PROD, start_date, end_date, RL, SFX = rx.findall(os.path.basename(infile)).pop()\n\n                start_yr[t] = int(start_date[:4])\n                end_yr[t] = int(end_date[:4])\n                month = int(start_date[4:6])\n\n            #-- Calculation of total days since start of campaign\n            #-- Get information on the current year (day per month and day per year)\n            dpm = gravity_toolkit.time.dpm_count(start_yr[t])\n\n            #-- find start day, end day\n            start_day[t] = np.sum(dpm[:np.int(month) - 1]) + 1\n            end_day[t] = np.sum(dpm[:np.int(month)])\n\n        # -- number of days in the starting year for leap and standard years\n        dpy = gravity_toolkit.time.calendar_days(start_yr[t]).sum()\n        #-- end date taking into account measurements taken on different years\n        end_cyclic = (end_yr[t]-start_yr[t])*dpy + end_day[t]\n        #-- calculate mid-month value\n        mid_day[t] = np.mean([start_day[t], end_cyclic])\n\n        #-- calculate Modified Julian Day from start_yr and mid_day\n        MJD = gravity_toolkit.time.convert_calendar_dates(start_yr[t],\n            1.0,mid_day[t],epoch=(1858,11,17,0,0,0))\n        #-- convert from Modified Julian Days to calendar dates\n        cal_date = gravity_toolkit.time.convert_julian(MJD+2400000.5)\n\n        #-- Calculating the mid-month date in decimal form\n        tdec[t] = start_yr[t] + mid_day[t]/dpy\n\n        #-- Calculation of total days since start of campaign\n        count = 0\n        n_yrs = np.int64(start_yr[t]-2002)\n        #-- for each of the GRACE years up to the file year\n        for iyr in range(n_yrs):\n            #-- year\n            year = 2002 + iyr\n            #-- add all days from prior years to count\n            #-- number of days in year i (if leap year or standard year)\n            count += gravity_toolkit.time.calendar_days(year).sum()\n\n        #-- calculating the total number of days since 2002\n        tot_days[t] = np.mean([count+start_day[t], count+end_cyclic])\n\n        #-- Calculates the month number (or 10-day number for CNES RL01,RL02)\n        if ((PROC == 'CNES') and (DREL in ('RL01','RL02'))):\n            mon[t] = np.round(1.0+(tot_days[t]-tot_days[0])/10.0)\n        else:\n            #-- calculate the GRACE/GRACE-FO month (Apr02 == 004)\n            #-- https://grace.jpl.nasa.gov/data/grace-months/\n            #-- Notes on special months (e.g. 119, 120) below\n            mon[t] = 12*(cal_date['year']-2002) + cal_date['month']\n\n    #-- The 'Special Months' (Nov 2011, Dec 2011 and April 2012) with\n    #-- Accelerometer shutoffs make the relation between month number\n    #-- and date more complicated as days from other months are used\n    #-- For CSR and GFZ: Nov 2011 (119) is centered in Oct 2011 (118)\n    #-- For JPL: Dec 2011 (120) is centered in Jan 2012 (121)\n    #-- For all: May 2015 (161) is centered in Apr 2015 (160)\n    mon = gravity_toolkit.time.adjust_months(mon)\n\n    #-- Output GRACE/GRACE-FO date ascii file\n    if OUTPUT:\n        date_file = '{0}_{1}_DATES.txt'.format(PROC, DREL)\n        fid = open(os.path.join(grace_dir,date_file), 'w')\n        #-- date file header information\n        args = ('Mid-date','Month','Start_Day','End_Day','Total_Days')\n        print('{0} {1:>10} {2:>11} {3:>10} {4:>13}'.format(*args),file=fid)\n\n    #-- create python dictionary mapping input file names with GRACE months\n    grace_files = {}\n    #-- for each data file\n    for t, infile in enumerate(input_files):\n        #-- add file to python dictionary mapped to GRACE/GRACE-FO month\n        grace_files[mon[t]] = os.path.join(grace_dir,infile)\n        #-- print to GRACE dates ascii file (NOTE: tot_days will be rounded)\n        if OUTPUT:\n            print(('{0:13.8f} {1:03d} {2:8.0f} {3:03.0f} {4:8.0f} {5:03.0f} '\n                '{6:8.0f}').format(tdec[t],mon[t],start_yr[t],start_day[t],\n                end_yr[t],end_day[t],tot_days[t]), file=fid)\n\n    #-- close date file\n    #-- set permissions level of output date file\n    if OUTPUT:\n        fid.close()\n        os.chmod(os.path.join(grace_dir, date_file), MODE)\n\n    #-- return the python dictionary that maps GRACE months with GRACE files\n    return grace_files\n\n#-- PURPOSE: program that calls grace_date() with set parameters\ndef main():\n    #-- command line parameters\n    #-- Read the system arguments listed after the program\n    parser = argparse.ArgumentParser(\n        description=\"\"\"Parses dates of each GRACE/GRACE-FO file and\n            assigns the month number.\n            Creates an index of dates for GRACE/GRACE-FO files.\n            \"\"\"\n    )\n    #-- working data directory\n    parser.add_argument('--directory','-D',\n        type=lambda p: os.path.abspath(os.path.expanduser(p)),\n        default=os.getcwd(),\n        help='Working data directory')\n    #-- GRACE/GRACE-FO data processing center\n    parser.add_argument('--center','-c',\n        metavar='PROC', type=str, nargs='+',\n        default=['CSR','GFZ','JPL'],\n        choices=['CSR','GFZ','JPL', 'CNES','GRAZ','SWARM', 'COSTG'],\n        help='GRACE/GRACE-FO Processing Center')\n    #-- GRACE/GRACE-FO data release\n    parser.add_argument('--release','-r',\n        metavar='DREL', type=str, nargs='+',\n        default=['RL06'],\n        help='GRACE/GRACE-FO Data Release')\n    #-- GRACE/GRACE-FO data product\n    parser.add_argument('--product','-p',\n        metavar='DSET', type=str.upper, nargs='+',\n        default=['GAC','GAD','GSM'],\n        choices=['GAA','GAB','GAC','GAD','GSM'],\n        help='GRACE/GRACE-FO Level-2 data product')\n    #-- output GRACE/GRACE-FO ascii date file\n    parser.add_argument('--output','-O',\n        default=False, action='store_true',\n        help='Overwrite existing data')\n    #-- permissions mode of the local directories and files (number in octal)\n    parser.add_argument('--mode','-M',\n        type=lambda x: int(x,base=8), default=0o775,\n        help='permissions mode of output files')\n    args,_ = parser.parse_known_args()\n\n    #-- run GRACE/GRACE-FO date program\n    for pr in args.center:\n        for rl in args.release:\n            for ds in args.product:\n                grace_date(args.directory, PROC=pr, DREL=rl, DSET=ds,\n                    OUTPUT=args.output, MODE=args.mode)\n\n#-- run main program\nif __name__ == '__main__':\n    main()\n", "meta": {"hexsha": "ff5beaf949c880a3a378a79356ece966d4f309b3", "size": 15094, "ext": "py", "lang": "Python", "max_stars_repo_path": "gravity_toolkit/grace_date.py", "max_stars_repo_name": "hulecom/read-GRACE-harmonics", "max_stars_repo_head_hexsha": "7e7cd756cc1875b4f85bfd516b7df5b44eec7684", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gravity_toolkit/grace_date.py", "max_issues_repo_name": "hulecom/read-GRACE-harmonics", "max_issues_repo_head_hexsha": "7e7cd756cc1875b4f85bfd516b7df5b44eec7684", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gravity_toolkit/grace_date.py", "max_forks_repo_name": "hulecom/read-GRACE-harmonics", "max_forks_repo_head_hexsha": "7e7cd756cc1875b4f85bfd516b7df5b44eec7684", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.4638554217, "max_line_length": 106, "alphanum_fraction": 0.6489996025, "include": true, "reason": "import numpy", "num_tokens": 4077, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4571367168274948, "lm_q2_score": 0.10970576369015277, "lm_q1q2_score": 0.05015053263036943}}
{"text": "# -*- coding: utf-8 -*-\n\nr\"\"\"\nThe :mod:`pyunlocbox.solvers` module implements a solving function (which will\nminimize your objective function) as well as common solvers.\n\nSolving\n-------\n\nCall :func:`solve` to solve your convex optimization problem using your\ninstantiated solver and functions objects.\n\nInterface\n---------\n\nThe :class:`solver` base class defines a common interface to all solvers:\n\n.. autosummary::\n\n    solver.pre\n    solver.algo\n    solver.post\n\nSolvers\n-------\n\nThen, derived classes implement various common solvers.\n\n.. autosummary::\n\n    gradient_descent\n    forward_backward\n    douglas_rachford\n    generalized_forward_backward\n\n**Primal-dual solvers** (based on :class:`primal_dual`)\n\n.. autosummary::\n\n    mlfbf\n    projection_based\n\n.. inheritance-diagram:: pyunlocbox.solvers\n    :parts: 2\n\n\"\"\"\n\nimport time\n\nimport numpy as np\n\nfrom pyunlocbox.functions import dummy, _prox_star\nfrom pyunlocbox import acceleration\n\n\ndef solve(functions, x0, solver=None, atol=None, dtol=None, rtol=1e-3,\n          xtol=None, maxit=200, verbosity='LOW', inplace=False):\n    r\"\"\"\n    Solve an optimization problem whose objective function is the sum of some\n    convex functions.\n\n    This function minimizes the objective function :math:`f(x) =\n    \\sum\\limits_{k=0}^{k=K} f_k(x)`, i.e. solves\n    :math:`\\operatorname{arg\\,min}\\limits_x f(x)` for :math:`x \\in\n    \\mathbb{R}^{n \\times N}` where :math:`n` is the dimensionality of the data\n    and :math:`N` the number of independent problems. It returns a dictionary\n    with the found solution and some informations about the algorithm\n    execution.\n\n    Parameters\n    ----------\n    functions : list of objects\n        A list of convex functions to minimize. These are objects who must\n        implement the :meth:`pyunlocbox.functions.func.eval` method. The\n        :meth:`pyunlocbox.functions.func.grad` and / or\n        :meth:`pyunlocbox.functions.func.prox` methods are required by some\n        solvers. Note also that some solvers can only handle two convex\n        functions while others may handle more. Please refer to the\n        documentation of the considered solver.\n    x0 : array_like\n        Starting point of the algorithm, :math:`x_0 \\in \\mathbb{R}^{n \\times\n        N}`.\n    solver : solver class instance, optional\n        The solver algorithm. It is an object who must inherit from\n        :class:`pyunlocbox.solvers.solver` and implement the :meth:`_pre`,\n        :meth:`_algo` and :meth:`_post` methods. If no solver object are\n        provided, a standard one will be chosen given the number of convex\n        function objects and their implemented methods.\n    atol : float, optional\n        The absolute tolerance stopping criterion. The algorithm stops when\n        :math:`f(x^t) < atol` where :math:`f(x^t)` is the objective function at\n        iteration :math:`t`. Default is None.\n    dtol : float, optional\n        Stop when the objective function is stable enough, i.e. when\n        :math:`\\left|f(x^t) - f(x^{t-1})\\right| < dtol`. Default is None.\n    rtol : float, optional\n        The relative tolerance stopping criterion. The algorithm stops when\n        :math:`\\left|\\frac{ f(x^t) - f(x^{t-1}) }{ f(x^t) }\\right| < rtol`.\n        Default is :math:`10^{-3}`.\n    xtol : float, optional\n        Stop when the variable is stable enough, i.e. when :math:`\\frac{\\|x^t -\n        x^{t-1}\\|_2}{\\sqrt{n N}} < xtol`. Note that additional memory will be\n        used to store :math:`x^{t-1}`. Default is None.\n    maxit : int, optional\n        The maximum number of iterations. Default is 200.\n    verbosity : {'NONE', 'LOW', 'HIGH', 'ALL'}, optional\n        The log level : ``'NONE'`` for no log, ``'LOW'`` for resume at\n        convergence, ``'HIGH'`` for info at all solving steps, ``'ALL'`` for\n        all possible outputs, including at each steps of the proximal operators\n        computation. Default is ``'LOW'``.\n    inplace : bool, optional\n        If True and x0 is a numpy array, then x0 will be modified in place\n        during execution to save memory. It will then contain the solution. Be\n        careful to pass data of the type (int, float32, float64) you want your\n        computations to use.\n\n    Returns\n    -------\n    sol : ndarray\n        The problem solution.\n    solver : str\n        The used solver.\n    crit : {'ATOL', 'DTOL', 'RTOL', 'XTOL', 'MAXIT'}\n        The used stopping criterion. See above for definitions.\n    niter : int\n        The number of iterations.\n    time : float\n        The execution time in seconds.\n    objective : ndarray\n        The successive evaluations of the objective function at each iteration.\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> from pyunlocbox import functions, solvers\n\n    Define a problem:\n\n    >>> y = [4, 5, 6, 7]\n    >>> f = functions.norm_l2(y=y)\n\n    Solve it:\n\n    >>> x0 = np.zeros(len(y))\n    >>> ret = solvers.solve([f], x0, atol=1e-2, verbosity='ALL')\n    INFO: Dummy objective function added.\n    INFO: Selected solver: forward_backward\n    INFO: Forward-backward method\n        dummy evaluation: 0.000000e+00\n        norm_l2 evaluation: 1.260000e+02\n    Iteration 1 of forward_backward:\n        dummy evaluation: 0.000000e+00\n        norm_l2 evaluation: 1.400000e+01\n        objective = 1.40e+01\n    Iteration 2 of forward_backward:\n        dummy evaluation: 0.000000e+00\n        norm_l2 evaluation: 2.963739e-01\n        objective = 2.96e-01\n    Iteration 3 of forward_backward:\n        dummy evaluation: 0.000000e+00\n        norm_l2 evaluation: 7.902529e-02\n        objective = 7.90e-02\n    Iteration 4 of forward_backward:\n        dummy evaluation: 0.000000e+00\n        norm_l2 evaluation: 5.752265e-02\n        objective = 5.75e-02\n    Iteration 5 of forward_backward:\n        dummy evaluation: 0.000000e+00\n        norm_l2 evaluation: 5.142032e-03\n        objective = 5.14e-03\n    Solution found after 5 iterations:\n        objective function f(sol) = 5.142032e-03\n        stopping criterion: ATOL\n\n    Verify the stopping criterion (should be smaller than atol=1e-2):\n\n    >>> np.linalg.norm(ret['sol'] - y)**2  # doctest:+ELLIPSIS\n    0.00514203...\n\n    Show the solution (should be close to y w.r.t. the L2-norm measure):\n\n    >>> ret['sol']\n    array([4.02555301, 5.03194126, 6.03832952, 7.04471777])\n\n    Show the used solver:\n\n    >>> ret['solver']\n    'forward_backward'\n\n    Show some information about the convergence:\n\n    >>> ret['crit']\n    'ATOL'\n    >>> ret['niter']\n    5\n    >>> ret['time']  # doctest:+SKIP\n    0.0012578964233398438\n    >>> ret['objective']  # doctest:+NORMALIZE_WHITESPACE,+ELLIPSIS\n    [[126.0, 0], [13.99999999..., 0], [0.29637392..., 0], [0.07902528..., 0],\n    [0.05752265..., 0], [0.00514203..., 0]]\n\n    \"\"\"\n    # to prevent any modification of the input\n    if not(inplace):\n        x0 = x0.copy()\n\n    if verbosity not in ['NONE', 'LOW', 'HIGH', 'ALL']:\n        raise ValueError('Verbosity should be either NONE, LOW, HIGH or ALL.')\n\n    # Add a second dummy convex function if only one function is provided.\n    if len(functions) < 1:\n        raise ValueError('At least 1 convex function should be provided.')\n    elif len(functions) == 1:\n        functions.append(dummy())\n        if verbosity in ['LOW', 'HIGH', 'ALL']:\n            print('INFO: Dummy objective function added.')\n\n    # Choose a solver if none provided.\n    if not solver:\n        if len(functions) == 2:\n            fb0 = 'GRAD' in functions[0].cap(x0) and \\\n                  'PROX' in functions[1].cap(x0)\n            fb1 = 'GRAD' in functions[1].cap(x0) and \\\n                  'PROX' in functions[0].cap(x0)\n            dg0 = 'PROX' in functions[0].cap(x0) and \\\n                  'PROX' in functions[1].cap(x0)\n            if fb0 or fb1:\n                solver = forward_backward()  # Need one prox and 1 grad.\n            elif dg0:\n                solver = douglas_rachford()  # Need two prox.\n            else:\n                raise ValueError('No suitable solver for the given functions.')\n        elif len(functions) > 2:\n            solver = generalized_forward_backward()\n        if verbosity in ['LOW', 'HIGH', 'ALL']:\n            name = solver.__class__.__name__\n            print('INFO: Selected solver: {}'.format(name))\n\n    # Set solver and functions verbosity.\n    translation = {'ALL': 'HIGH', 'HIGH': 'HIGH', 'LOW': 'LOW', 'NONE': 'NONE'}\n    solver.verbosity = translation[verbosity]\n    translation = {'ALL': 'HIGH', 'HIGH': 'LOW', 'LOW': 'NONE', 'NONE': 'NONE'}\n    functions_verbosity = []\n    for f in functions:\n        functions_verbosity.append(f.verbosity)\n        f.verbosity = translation[verbosity]\n\n    tstart = time.time()\n    crit = None\n    niter = 0\n    rtol_only_zeros = True\n\n    # Solver specific initialization.\n    solver.pre(functions, x0)\n\n    # Evaluate the objective function at the begining\n    objective = [solver.objective(x0)]\n\n    while not crit:\n\n        niter += 1\n\n        if xtol is not None:\n            last_sol = np.array(solver.sol, copy=True)\n\n        if verbosity in ['HIGH', 'ALL']:\n            name = solver.__class__.__name__\n            print('Iteration {} of {}:'.format(niter, name))\n\n        # Solver iterative algorithm.\n        solver.algo(objective, niter)\n\n        objective.append(solver.objective(solver.sol))\n        current = np.sum(objective[-1])\n        last = np.sum(objective[-2])\n\n        # Verify stopping criteria.\n        if atol is not None and current < atol:\n            crit = 'ATOL'\n        if dtol is not None and np.abs(current - last) < dtol:\n            crit = 'DTOL'\n        if rtol is not None:\n            div = current  # Prevent division by 0.\n            if div == 0:\n                if verbosity in ['LOW', 'HIGH', 'ALL']:\n                    print('WARNING: (rtol) objective function is equal to 0 !')\n                if last != 0:\n                    div = last\n                else:\n                    div = 1.0  # Result will be zero anyway.\n            else:\n                rtol_only_zeros = False\n            relative = np.abs((current - last) / div)\n            if relative < rtol and not rtol_only_zeros:\n                crit = 'RTOL'\n        if xtol is not None:\n            err = np.linalg.norm(solver.sol - last_sol)\n            err /= np.sqrt(last_sol.size)\n            if err < xtol:\n                crit = 'XTOL'\n        if maxit is not None and niter >= maxit:\n            crit = 'MAXIT'\n\n        if verbosity in ['HIGH', 'ALL']:\n            print('    objective = {:.2e}'.format(current))\n\n    # Restore verbosity for functions. In case they are called outside solve().\n    for k, f in enumerate(functions):\n        f.verbosity = functions_verbosity[k]\n\n    if verbosity in ['LOW', 'HIGH', 'ALL']:\n        print('Solution found after {} iterations:'.format(niter))\n        print('    objective function f(sol) = {:e}'.format(current))\n        print('    stopping criterion: {}'.format(crit))\n\n    # Returned dictionary.\n    result = {'sol':       solver.sol,\n              'solver':    solver.__class__.__name__,  # algo for consistency ?\n              'crit':      crit,\n              'niter':     niter,\n              'time':      time.time() - tstart,\n              'objective': objective}\n    try:\n        # Update dictionary for primal-dual solvers\n        result['dual_sol'] = solver.dual_sol\n    except AttributeError:\n        pass\n\n    # Solver specific post-processing (e.g. delete references).\n    solver.post()\n\n    return result\n\n\nclass solver(object):\n    r\"\"\"\n    Defines the solver object interface.\n\n    This class defines the interface of a solver object intended to be passed\n    to the :func:`pyunlocbox.solvers.solve` solving function. It is intended to\n    be a base class for standard solvers which will implement the required\n    methods. It can also be instantiated by user code and dynamically modified\n    for rapid testing. This class also defines the generic attributes of all\n    solver objects.\n\n    Parameters\n    ----------\n    step : float\n        The gradient-descent step-size. This parameter is bounded by 0 and\n        :math:`\\frac{2}{\\beta}` where :math:`\\beta` is the Lipschitz constant\n        of the gradient of the smooth function (or a sum of smooth functions).\n        Default is 1.\n    accel : pyunlocbox.acceleration.accel\n        User-defined object used to adaptively change the current step size\n        and solution while the algorithm is running. Default is a dummy\n        object that returns unchanged values.\n\n    \"\"\"\n\n    def __init__(self, step=1., accel=None):\n        if step < 0:\n            raise ValueError('Step should be a positive number.')\n        self.step = step\n        self.accel = acceleration.dummy() if accel is None else accel\n\n    def pre(self, functions, x0):\n        \"\"\"\n        Solver-specific pre-processing. See parameters documentation in\n        :func:`pyunlocbox.solvers.solve` documentation.\n\n        Notes\n        -----\n        When preprocessing the functions, the solver should split them into\n        two lists:\n        * `self.smooth_funs`, for functions involved in gradient steps.\n        * `self.non_smooth_funs`, for functions involved proximal steps.\n        This way, any method that takes in the solver as argument, such as the\n        methods in :class:`pyunlocbox.acceleration.accel`, can have some\n        context as to how the solver is using the functions.\n\n        \"\"\"\n        self.sol = np.asarray(x0)\n        self.smooth_funs = []\n        self.non_smooth_funs = []\n        self._pre(functions, self.sol)\n        self.accel.pre(functions, self.sol)\n\n    def _pre(self, functions, x0):\n        raise NotImplementedError(\"Class user should define this method.\")\n\n    def algo(self, objective, niter):\n        \"\"\"\n        Call the solver iterative algorithm and the provided acceleration\n        scheme. See parameters documentation in\n        :func:`pyunlocbox.solvers.solve`\n\n        Notes\n        -----\n        The method :meth:`self.accel.update_sol` is called before\n        :meth:`self._algo` because the acceleration schemes usually involves\n        some sort of averaging of previous solutions, which can add some\n        unwanted artifacts on the output solution. With this ordering, we\n        guarantee that the output of solver.algo is not corrupted by the\n        acceleration scheme.\n\n        Similarly, the method :meth:`self.accel.update_step` is called after\n        :meth:`self._algo` to allow the step update procedure to act directly\n        on the solution output by the underlying algorithm, and not on the\n        intermediate solution output by the acceleration scheme in\n        :meth:`self.accel.update_sol`.\n\n        \"\"\"\n        self.sol[:] = self.accel.update_sol(self, objective, niter)\n        self.step = self.accel.update_step(self, objective, niter)\n        self._algo()\n\n    def _algo(self):\n        raise NotImplementedError(\"Class user should define this method.\")\n\n    def post(self):\n        \"\"\"\n        Solver-specific post-processing. Mainly used to delete references added\n        during initialization so that the garbage collector can free the\n        memory. See parameters documentation in\n        :func:`pyunlocbox.solvers.solve`.\n\n        \"\"\"\n        self._post()\n        self.accel.post()\n        del self.sol, self.smooth_funs, self.non_smooth_funs\n\n    def _post(self):\n        raise NotImplementedError(\"Class user should define this method.\")\n\n    def objective(self, x):\n        \"\"\"\n        Return the objective function at x.\n\n        Necessitate `solver._pre(...)` to be run first.\n        \"\"\"\n        return self._objective(x)\n\n    def _objective(self, x):\n        obj_smooth = [f.eval(x) for f in self.smooth_funs]\n        obj_nonsmooth = [f.eval(x) for f in self.non_smooth_funs]\n        return obj_nonsmooth + obj_smooth\n\n\nclass gradient_descent(solver):\n    r\"\"\"\n    Gradient descent algorithm.\n\n    This algorithm solves optimization problems composed of the sum of\n    any number of smooth functions.\n\n    See generic attributes descriptions of the\n    :class:`pyunlocbox.solvers.solver` base class.\n\n    Notes\n    -----\n    This algorithm requires each function implement the\n    :meth:`pyunlocbox.functions.func.grad` method.\n\n    See :class:`pyunlocbox.acceleration.regularized_nonlinear` for a very\n    efficient acceleration scheme for this method.\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> from pyunlocbox import functions, solvers\n    >>> dim = 25\n    >>> np.random.seed(0)\n    >>> xstar = np.random.rand(dim)  # True solution\n    >>> x0 = np.random.rand(dim)\n    >>> x0 = xstar + 5*(x0 - xstar) / np.linalg.norm(x0 - xstar)\n    >>> A = np.random.rand(dim, dim)\n    >>> step = 1 / np.linalg.norm(np.dot(A.T, A))\n    >>> f = functions.norm_l2(lambda_=0.5, A=A, y=np.dot(A, xstar))\n    >>> fd = functions.dummy()\n    >>> solver = solvers.gradient_descent(step=step)\n    >>> params = {'rtol':0, 'maxit':14000, 'verbosity':'NONE'}\n    >>> ret = solvers.solve([f, fd], x0, solver, **params)\n    >>> pctdiff = 100 * np.sum((xstar - ret['sol'])**2) / np.sum(xstar**2)\n    >>> print('Difference: {0:.1f}%'.format(pctdiff))\n    Difference: 1.3%\n\n    \"\"\"\n\n    def __init__(self, **kwargs):\n        super(gradient_descent, self).__init__(**kwargs)\n\n    def _pre(self, functions, x0):\n\n        for f in functions:\n            if 'GRAD' in f.cap(x0):\n                self.smooth_funs.append(f)\n            else:\n                raise ValueError('Gradient descent requires each function to '\n                                 'implement grad().')\n\n        if self.verbosity == 'HIGH':\n            print('INFO: Gradient descent minimizing {} smooth '\n                  'functions.'.format(len(self.smooth_funs)))\n\n    def _algo(self):\n        grad = np.zeros_like(self.sol)\n        for f in self.smooth_funs:\n            grad += f.grad(self.sol)\n        self.sol[:] -= self.step * grad\n\n    def _post(self):\n        pass\n\n\nclass forward_backward(solver):\n    r\"\"\"\n    Forward-backward proximal splitting (FISTA and ISTA) algorithm.\n\n    This algorithm solves convex optimization problems composed of the sum of\n    a smooth and a non-smooth function.\n\n    See generic attributes descriptions of the\n    :class:`pyunlocbox.solvers.solver` base class.\n\n    Parameters\n    ----------\n    accel : :class:`pyunlocbox.acceleration.accel`\n        Acceleration scheme to use.\n        Default is :meth:`pyunlocbox.acceleration.fista`, which corresponds\n        to the 'FISTA' solver. Passing :meth:`pyunlocbox.acceleration.dummy`\n        instead results in the ISTA solver. Note that while FISTA is much more\n        time-efficient, it is less memory-efficient.\n\n    Notes\n    -----\n    This algorithm requires one function to implement the\n    :meth:`pyunlocbox.functions.func.prox` method and the other one to\n    implement the :meth:`pyunlocbox.functions.func.grad` method.\n\n    See :cite:`beck2009FISTA` for details about the algorithm.\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> from pyunlocbox import functions, solvers\n    >>> y = [4, 5, 6, 7]\n    >>> x0 = np.zeros(len(y))\n    >>> f1 = functions.norm_l2(y=y)\n    >>> f2 = functions.dummy()\n    >>> solver = solvers.forward_backward(step=0.5)\n    >>> ret = solvers.solve([f1, f2], x0, solver, atol=1e-5)\n    Solution found after 15 iterations:\n        objective function f(sol) = 4.957288e-07\n        stopping criterion: ATOL\n    >>> ret['sol']\n    array([4.0002509 , 5.00031362, 6.00037635, 7.00043907])\n\n    \"\"\"\n\n    def __init__(self, accel=acceleration.fista(), **kwargs):\n        super(forward_backward, self).__init__(accel=accel, **kwargs)\n\n    def _pre(self, functions, x0):\n\n        if self.verbosity == 'HIGH':\n            print('INFO: Forward-backward method')\n\n        if len(functions) != 2:\n            raise ValueError('Forward-backward requires two convex functions.')\n\n        if 'PROX' in functions[0].cap(x0) and 'GRAD' in functions[1].cap(x0):\n            self.smooth_funs.append(functions[1])\n            self.non_smooth_funs.append(functions[0])\n        elif 'PROX' in functions[1].cap(x0) and 'GRAD' in functions[0].cap(x0):\n            self.smooth_funs.append(functions[0])\n            self.non_smooth_funs.append(functions[1])\n        else:\n            raise ValueError('Forward-backward requires a function to '\n                             'implement prox() and the other grad().')\n\n    def _algo(self):\n        # Forward step\n        x = self.sol - self.step * self.smooth_funs[0].grad(self.sol)\n        # Backward step\n        self.sol[:] = self.non_smooth_funs[0].prox(x, self.step)\n\n    def _post(self):\n        pass\n\n\nclass generalized_forward_backward(solver):\n    r\"\"\"\n    Generalized forward-backward proximal splitting algorithm.\n\n    This algorithm solves convex optimization problems composed of the sum of\n    any number of non-smooth (or smooth) functions.\n\n    See generic attributes descriptions of the\n    :class:`pyunlocbox.solvers.solver` base class.\n\n    Parameters\n    ----------\n    lambda_ : float, optional\n        A relaxation parameter bounded by 0 and 1. Default is 1.\n\n    Notes\n    -----\n    This algorithm requires each function to either implement the\n    :meth:`pyunlocbox.functions.func.prox` method or the\n    :meth:`pyunlocbox.functions.func.grad` method.\n\n    See :cite:`raguet2013generalizedFB` for details about the algorithm.\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> from pyunlocbox import functions, solvers\n    >>> y = [0.01, 0.2, 8, 0.3, 0 , 0.03, 7]\n    >>> x0 = np.zeros(len(y))\n    >>> f1 = functions.norm_l2(y=y)\n    >>> f2 = functions.norm_l1()\n    >>> solver = solvers.generalized_forward_backward(lambda_=1, step=0.5)\n    >>> ret = solvers.solve([f1, f2], x0, solver)\n    Solution found after 2 iterations:\n        objective function f(sol) = 1.463100e+01\n        stopping criterion: RTOL\n    >>> ret['sol']\n    array([0. , 0. , 7.5, 0. , 0. , 0. , 6.5])\n\n    \"\"\"\n\n    def __init__(self, lambda_=1, *args, **kwargs):\n        super(generalized_forward_backward, self).__init__(*args, **kwargs)\n        self.lambda_ = lambda_\n\n    def _pre(self, functions, x0):\n\n        if self.lambda_ <= 0 or self.lambda_ > 1:\n            raise ValueError('Lambda is bounded by 0 and 1.')\n\n        self.z = []\n        for f in functions:\n            if 'GRAD' in f.cap(x0):\n                self.smooth_funs.append(f)\n            elif 'PROX' in f.cap(x0):\n                self.non_smooth_funs.append(f)\n                self.z.append(np.array(x0, copy=True))\n            else:\n                raise ValueError('Generalized forward-backward requires each '\n                                 'function to implement prox() or grad().')\n\n        if self.verbosity == 'HIGH':\n            print('INFO: Generalized forward-backward minimizing {} smooth '\n                  'functions and {} non-smooth functions.'.format(\n                      len(self.smooth_funs), len(self.non_smooth_funs)))\n\n    def _algo(self):\n\n        # Smooth functions.\n        grad = np.zeros_like(self.sol)\n        for f in self.smooth_funs:\n            grad += f.grad(self.sol)\n\n        # Non-smooth functions.\n        if not self.non_smooth_funs:\n            self.sol[:] -= self.step * grad  # Reduces to gradient descent.\n        else:\n            sol = np.zeros_like(self.sol)\n            for i, g in enumerate(self.non_smooth_funs):\n                tmp = 2 * self.sol - self.z[i] - self.step * grad\n                tmp[:] = g.prox(tmp, self.step * len(self.non_smooth_funs))\n                self.z[i] += self.lambda_ * (tmp - self.sol)\n                sol += 1. * self.z[i] / len(self.non_smooth_funs)\n            self.sol[:] = sol\n\n    def _post(self):\n        del self.z\n\n\nclass douglas_rachford(solver):\n    r\"\"\"\n    Douglas-Rachford proximal splitting algorithm.\n\n    This algorithm solves convex optimization problems composed of the sum of\n    two non-smooth (or smooth) functions.\n\n    See generic attributes descriptions of the\n    :class:`pyunlocbox.solvers.solver` base class.\n\n    Parameters\n    ----------\n    lambda_ : float, optional\n        The update term weight. It should be between 0 and 1. Default is 1.\n\n    Notes\n    -----\n    This algorithm requires the two functions to implement the\n    :meth:`pyunlocbox.functions.func.prox` method.\n\n    See :cite:`combettes2007DR` for details about the algorithm.\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> from pyunlocbox import functions, solvers\n    >>> y = [4, 5, 6, 7]\n    >>> x0 = np.zeros(len(y))\n    >>> f1 = functions.norm_l2(y=y)\n    >>> f2 = functions.dummy()\n    >>> solver = solvers.douglas_rachford(lambda_=1, step=1)\n    >>> ret = solvers.solve([f1, f2], x0, solver, atol=1e-5)\n    Solution found after 8 iterations:\n        objective function f(sol) = 2.927052e-06\n        stopping criterion: ATOL\n    >>> ret['sol']\n    array([3.99939034, 4.99923792, 5.99908551, 6.99893309])\n\n    \"\"\"\n\n    def __init__(self, lambda_=1, *args, **kwargs):\n        super(douglas_rachford, self).__init__(*args, **kwargs)\n        self.lambda_ = lambda_\n\n    def _pre(self, functions, x0):\n\n        if self.lambda_ <= 0 or self.lambda_ > 1:\n            raise ValueError('Lambda is bounded by 0 and 1.')\n\n        if len(functions) != 2:\n            raise ValueError('Douglas-Rachford requires two convex functions.')\n\n        for f in functions:\n            if 'PROX' in f.cap(x0):\n                self.non_smooth_funs.append(f)\n            else:\n                raise ValueError('Douglas-Rachford requires each '\n                                 'function to implement prox().')\n\n        self.z = np.array(x0, copy=True)\n\n    def _algo(self):\n        tmp = self.non_smooth_funs[0].prox(2 * self.sol - self.z, self.step)\n        self.z[:] = self.z + self.lambda_ * (tmp - self.sol)\n        self.sol[:] = self.non_smooth_funs[1].prox(self.z, self.step)\n\n    def _post(self):\n        del self.z\n\n\nclass primal_dual(solver):\n    r\"\"\"\n    Parent class of all primal-dual algorithms.\n\n    See generic attributes descriptions of the\n    :class:`pyunlocbox.solvers.solver` base class.\n\n    Parameters\n    ----------\n    L : function or ndarray, optional\n        The transformation L that maps from the primal variable space to the\n        dual variable space. Default is the identity, :math:`L(x)=x`. If `L` is\n        an ``ndarray``, it will be converted to the operator form.\n    Lt : function or ndarray, optional\n        The adjoint operator. If `Lt` is an ``ndarray``, it will be converted\n        to the operator form. If `L` is an ``ndarray``, default is the\n        transpose of `L`. If `L` is a function, default is `L`,\n        :math:`Lt(x)=L(x)`.\n    d0: ndarray, optional\n        Initialization of the dual variable.\n\n    \"\"\"\n\n    def __init__(self, L=None, Lt=None, d0=None, *args, **kwargs):\n        super(primal_dual, self).__init__(*args, **kwargs)\n\n        if L is None:\n            self.L = lambda x: x\n        else:\n            if callable(L):\n                self.L = L\n            else:\n                # Transform matrix form to operator form.\n                self.L = lambda x: L.dot(x)\n\n        if Lt is None:\n            if L is None:\n                self.Lt = lambda x: x\n            elif callable(L):\n                self.Lt = L\n            else:\n                self.Lt = lambda x: L.T.dot(x)\n        else:\n            if callable(Lt):\n                self.Lt = Lt\n            else:\n                self.Lt = lambda x: Lt.dot(x)\n\n        self.d0 = d0\n\n    def _pre(self, functions, x0):\n        # Dual variable.\n        if self.d0 is None:\n            # The copy is necessary in case `L = lambda x: x`.\n            self.dual_sol = self.L(np.asarray(x0).copy())\n        else:\n            self.dual_sol = self.d0\n\n    def _post(self):\n        self.d0 = None\n        del self.dual_sol\n\n    def _objective(self, x):\n        obj_smooth = [f.eval(x) for f in self.smooth_funs]\n        obj_nonsmooth = [self.non_smooth_funs[0].eval(x),\n                         self.non_smooth_funs[1].eval(self.L(x))]\n        return obj_nonsmooth + obj_smooth\n\n\nclass mlfbf(primal_dual):\n    r\"\"\"\n    Monotone+Lipschitz forward-backward-forward primal-dual algorithm.\n\n    This algorithm solves convex optimization problems with objective of the\n    form :math:`f(x) + g(Lx) + h(x)`, where :math:`f` and :math:`g` are proper,\n    convex, lower-semicontinuous functions with easy-to-compute proximity\n    operators, and :math:`h` has Lipschitz-continuous gradient with constant\n    :math:`\\beta`.\n\n    See generic attributes descriptions of the\n    :class:`pyunlocbox.solvers.primal_dual` base class.\n\n    Notes\n    -----\n    The order of the functions matters: set :math:`f` first on the list,\n    :math:`g` second, and :math:`h` third.\n\n    This algorithm requires the first two functions to implement the\n    :meth:`pyunlocbox.functions.func.prox` method, and the third function to\n    implement the :meth:`pyunlocbox.functions.func.grad` method.\n\n    The step-size should be in the interval :math:`\\left] 0, \\frac{1}{\\beta +\n    \\|L\\|_{2}}\\right[`.\n\n    See :cite:`komodakis2015primaldual`, Algorithm 6, for details.\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> from pyunlocbox import functions, solvers\n    >>> y = np.array([294, 390, 361])\n    >>> L = np.array([[5, 9, 3], [7, 8, 5], [4, 4, 9], [0, 1, 7]])\n    >>> x0 = np.zeros(len(y))\n    >>> f = functions.dummy()\n    >>> f._prox = lambda x, T: np.maximum(np.zeros(len(x)), x)\n    >>> g = functions.norm_l2(lambda_=0.5)\n    >>> h = functions.norm_l2(y=y, lambda_=0.5)\n    >>> max_step = 1/(1 + np.linalg.norm(L, 2))\n    >>> solver = solvers.mlfbf(L=L, step=max_step/2.)\n    >>> ret = solvers.solve([f, g, h], x0, solver, maxit=1000, rtol=0)\n    Solution found after 1000 iterations:\n        objective function f(sol) = 1.839060e+05\n        stopping criterion: MAXIT\n    >>> ret['sol']\n    array([1., 1., 1.])\n\n    \"\"\"\n\n    def _pre(self, functions, x0):\n        super(mlfbf, self)._pre(functions, x0)\n\n        if len(functions) != 3:\n            raise ValueError('MLFBF requires 3 convex functions.')\n\n        self.non_smooth_funs.append(functions[0])   # f\n        self.non_smooth_funs.append(functions[1])   # g\n        self.smooth_funs.append(functions[2])       # h\n\n    def _algo(self):\n        # Forward steps (in both primal and dual spaces)\n        y1 = self.sol - self.step * (self.smooth_funs[0].grad(self.sol) +\n                                     self.Lt(self.dual_sol))\n        y2 = self.dual_sol + self.step * self.L(self.sol)\n\n        # Backward steps (in both primal and dual spaces)\n        p1 = self.non_smooth_funs[0].prox(y1, self.step)\n        p2 = _prox_star(self.non_smooth_funs[1], y2, self.step)\n\n        # Forward steps (in both primal and dual spaces)\n        q1 = p1 - self.step * (self.smooth_funs[0].grad(p1) + self.Lt(p2))\n        q2 = p2 + self.step * self.L(p1)\n\n        # Update solution (in both primal and dual spaces)\n        self.sol[:] = self.sol - y1 + q1\n        self.dual_sol[:] = self.dual_sol - y2 + q2\n\n\nclass projection_based(primal_dual):\n    r\"\"\"\n    Projection-based primal-dual algorithm.\n\n    This algorithm solves convex optimization problems with objective of the\n    form :math:`f(x) + g(Lx)`, where :math:`f` and :math:`g` are proper,\n    convex, lower-semicontinuous functions with easy-to-compute proximity\n    operators.\n\n    See generic attributes descriptions of the\n    :class:`pyunlocbox.solvers.primal_dual` base class.\n\n    Parameters\n    ----------\n    lambda_ : float, optional\n        The update term weight. It should be between 0 and 2. Default is 1.\n\n    Notes\n    -----\n    The order of the functions matters: set :math:`f` first on the list, and\n    :math:`g` second.\n\n    This algorithm requires the two functions to implement the\n    :meth:`pyunlocbox.functions.func.prox` method.\n\n    The step-size should be in the interval :math:`\\left] 0, \\infty \\right[`.\n\n    See :cite:`komodakis2015primaldual`, Algorithm 7, for details.\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> from pyunlocbox import functions, solvers\n    >>> y = np.array([294, 390, 361])\n    >>> L = np.array([[5, 9, 3], [7, 8, 5], [4, 4, 9], [0, 1, 7]])\n    >>> x0 = np.array([500, 1000, -400])\n    >>> f = functions.norm_l1(y=y)\n    >>> g = functions.norm_l1()\n    >>> solver = solvers.projection_based(L=L, step=1.)\n    >>> ret = solvers.solve([f, g], x0, solver, maxit=1000, rtol=None, xtol=.1)\n    Solution found after 996 iterations:\n        objective function f(sol) = 1.045000e+03\n        stopping criterion: XTOL\n    >>> ret['sol']\n    array([0, 0, 0])\n\n    \"\"\"\n\n    def __init__(self, lambda_=1., *args, **kwargs):\n        super(projection_based, self).__init__(*args, **kwargs)\n        self.lambda_ = lambda_\n\n    def _pre(self, functions, x0):\n        super(projection_based, self)._pre(functions, x0)\n\n        if self.lambda_ <= 0 or self.lambda_ > 2:\n            raise ValueError('Lambda is bounded by 0 and 2.')\n\n        if len(functions) != 2:\n            raise ValueError('projection_based requires 2 convex functions.')\n\n        self.non_smooth_funs.append(functions[0])   # f\n        self.non_smooth_funs.append(functions[1])   # g\n\n    def _algo(self):\n        a = self.non_smooth_funs[0].prox(self.sol - self.step *\n                                         self.Lt(self.dual_sol), self.step)\n        ell = self.L(self.sol)\n        b = self.non_smooth_funs[1].prox(ell + self.step * self.dual_sol,\n                                         self.step)\n        s = (self.sol - a) / self.step + self.Lt(ell - b) / self.step\n        t = b - self.L(a)\n        tau = np.sum(s**2) + np.sum(t**2)\n        if tau == 0:\n            self.sol[:] = a\n            self.dual_sol[:] = self.dual_sol + (ell - b) / self.step\n        else:\n            theta = self.lambda_ * (np.sum((self.sol - a)**2) / self.step +\n                                    np.sum((ell - b)**2) / self.step) / tau\n            self.sol[:] = self.sol - theta * s\n            self.dual_sol[:] = self.dual_sol - theta * t\n", "meta": {"hexsha": "ac4203f6fe54e560ba1ca80a2de358fb74dfd5a6", "size": 34026, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyunlocbox/solvers.py", "max_stars_repo_name": "vishalbelsare/pyunlocbox", "max_stars_repo_head_hexsha": "66181218a3268444983233720f0dc10392c15d5a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 90, "max_stars_repo_stars_event_min_datetime": "2015-12-12T07:04:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T17:47:05.000Z", "max_issues_repo_path": "pyunlocbox/solvers.py", "max_issues_repo_name": "vishalbelsare/pyunlocbox", "max_issues_repo_head_hexsha": "66181218a3268444983233720f0dc10392c15d5a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 38, "max_issues_repo_issues_event_min_datetime": "2015-02-05T20:41:07.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-10T11:03:09.000Z", "max_forks_repo_path": "pyunlocbox/solvers.py", "max_forks_repo_name": "vishalbelsare/pyunlocbox", "max_forks_repo_head_hexsha": "66181218a3268444983233720f0dc10392c15d5a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 26, "max_forks_repo_forks_event_min_datetime": "2015-02-04T09:55:04.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-23T09:18:47.000Z", "avg_line_length": 34.7914110429, "max_line_length": 79, "alphanum_fraction": 0.6045083172, "include": true, "reason": "import numpy", "num_tokens": 8794, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41489884579676883, "lm_q2_score": 0.12085324040654355, "lm_q1q2_score": 0.050141869955474344}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# # Week 1\n# \n# IPL (Indian Premier League) (cricket)\n\n# # Imports\n\n# In[1]:\n\n\n# %load /Users/bartev/dev/github-bv/sporty/notebooks/imports.py\n# %load /Users/bartev/dev/github-bv/sporty/notebooks/imports.py\n\n## Where am I\nget_ipython().system('echo $VIRTUAL_ENV')\n\nfrom IPython.core.display import display, HTML\ndisplay(HTML(\"<style>.container { width:95% !important; }</style>\"))\n\n# magics\nget_ipython().run_line_magic('load_ext', 'blackcellmagic')\n# start cell with `%%black` to format using `black`\n\nget_ipython().run_line_magic('load_ext', 'autoreload')\n# start cell with `%autoreload` to reload module\n# https://ipython.org/ipython-doc/stable/config/extensions/autoreload.html\n\n# reload all modules when running\nget_ipython().run_line_magic('autoreload', '2')\n\n\n# In[2]:\n\n\n# imports\n\nimport pandas as pd\nimport numpy as np\nimport statsmodels.formula.api as smf\nimport seaborn as sns\n\nfrom importlib import reload\nfrom pathlib import Path\n\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nget_ipython().run_line_magic('matplotlib', 'inline')\n\n# https://plotnine.readthedocs.io/en/stable/\n\nimport plotnine as p9\nfrom plotnine import ggplot, aes, facet_wrap\n\n\n# In[30]:\n\n\nget_ipython().system('pip install xlrd')\n\n\n# In[32]:\n\n\nget_ipython().system('pip install openpyxl')\n\n\n# # Read data\n\n# Need `IPL2018teams` data\n# \n# * https://www.kaggle.com/manasgarg/ipl\n\n# ## archive\n# \n# 2008-2017\ndata_dir = Path('/Users/bartev/dev/github-bv/sporty/data/raw/wk1-IPL/archive')\nmatches = pd.read_csv(data_dir / 'matches.csv')\n\ndeliveries = pd.read_csv(data_dir / 'deliveries.csv')deliveries.head()matches.groupby('season').size()\n# ## archive 2\n# 2008 - 2019\ndata_dir2 = Path('/Users/bartev/dev/github-bv/sporty/data/raw/wk1-IPL/archive 2')\nmatches2 = pd.read_csv(data_dir2 / 'matches.csv')\ndeliveries2 = pd.read_csv(data_dir2 / 'deliveries.csv')matches2.groupby('season').size()deliveries2\n# ## archive-3\n# \n# I found this data somewhere on Kaggle (didn't keep the link)\n# \n# More data than `archive 2`?\n\n# In[157]:\n\n\ndata_dir = Path('/Users/bartev/dev/github-bv/sporty/data/raw/wk1-IPL/archive-3')\nmatches = pd.read_csv(data_dir3 / 'matches.csv')\ndeliveries = pd.read_csv(data_dir3/ 'deliveries.csv')\nteams = pd.read_csv(data_dir3 / 'teams.csv')\nteamwise = pd.read_csv(data_dir3 / 'teamwise_home_and_away.csv')\nplayers = pd.read_excel(data_dir3 / 'Players.xlsx')\n\n\n# In[158]:\n\n\nmatches.groupby('Season').size()\n\n\n# In[63]:\n\n\ndeliveries.head()\n\n\n# In[64]:\n\n\nmatches.head(2)\n\n\n# In[159]:\n\n\nteamwise\n\n\n# In[ ]:\n\n\nipl18 = matches.query(\"Season == 'IPL-2018'\").assign(\n    hwin=lambda x: np.where(x[\"team1\"] == x[\"winner\"], 1, 0),\n    awin=lambda x: np.where(x[\"team2\"] == x[\"winner\"], 1, 0),\n    #                 htruns=lambda x: np.where(x['team1'] == x[''])\n)\nipl18\n\n\n# In[101]:\n\n\n# get the match ids for season 2018\nmatch_ids_2018 = ipl18[\"id\"]\n\n# Count runs scored by each team for season 2018\nmatch_team_runs = (\n    deliveries[[\"match_id\", \"inning\", \"batting_team\", \"bowling_team\", \"total_runs\"]]\n    .merge(match_ids_2018, left_on=\"match_id\", right_on=\"id\")\n    .groupby([\"match_id\", \"batting_team\"])\n    .agg({\"total_runs\": sum})\n    .reset_index()\n    .rename(columns={\"match_id\": \"id\"})\n)\nmatch_team_runs.head(5)\n\n\n# In[133]:\n\n\nipl_cols = [\n    \"id\",\n    \"Season\",\n    \"date\",\n    \"team1\",\n    \"team2\",\n    \"winner\",\n    \"win_by_runs\",\n    \"win_by_wickets\",\n    \"hwin\",\n    \"awin\",\n]\n\nipl18_exp = (\n    ipl18[ipl_cols]\n    .rename(columns={\"team1\": \"home_team\", \"team2\": \"away_team\"})\n    .merge(\n        match_team_runs, left_on=[\"id\", \"home_team\"], right_on=[\"id\", \"batting_team\"]\n    )\n    .drop(columns=\"batting_team\")\n    .rename(columns={\"total_runs\": \"htruns\"})\n    .merge(\n        match_team_runs, left_on=[\"id\", \"away_team\"], right_on=[\"id\", \"batting_team\"]\n    )\n    .drop(columns=\"batting_team\")\n    .rename(columns={\"total_runs\": \"atruns\"})\n    .assign(\n        my_hwin=lambda x: np.where(x[\"home_team\"] == x[\"winner\"], 1, 0),\n        my_awin=lambda x: np.where(x[\"away_team\"] == x[\"winner\"], 1, 0),\n    )\n    #     .assign(match=lambda x: x['hwin'] == x['my_hwin'])\n    .assign(count=1)\n)\n\n\n# In[134]:\n\n\nipl18_exp\n\n\n# * Ph/Pa : number of games played at home/away\n\n# In[143]:\n\n\niplhome = (\n    ipl18_exp.groupby(\"home_team\")[\"count\", \"hwin\", \"htruns\", \"atruns\"]\n    .sum()\n    .reset_index()\n    .rename(\n        columns={\n            \"home_team\": \"team\",\n            \"count\": \"Ph\",\n            \"htruns\": \"htrunsh\",\n            \"atruns\": \"atrunsh\",\n        }\n    )\n)\niplhome\n\n\n# In[144]:\n\n\niplaway = (\n    ipl18_exp.groupby(\"away_team\")[\"count\", \"awin\", \"htruns\", \"atruns\"]\n    .sum()\n    .reset_index()\n    .rename(\n        columns={\n            \"away_team\": \"team\",\n            \"count\": \"Pa\",\n            \"htruns\": \"htrunsa\",\n            \"atruns\": \"atrunsa\",\n        }\n    )\n)\niplaway\n\n\n# In[151]:\n\n\nipl18_combo = (\n    iplhome.merge(iplaway, on=\"team\")\n    # aggregate home/away data for wins, games played, and runs\n    .assign(\n        W=lambda x: x[\"hwin\"] + x[\"awin\"],\n        G=lambda x: x[\"Ph\"] + x[\"Pa\"],\n        R=lambda x: x[\"htrunsh\"] + x[\"atrunsa\"],\n        RA=lambda x: x[\"atrunsh\"] + x[\"htrunsa\"],\n    )\n    # get win percentage and pythagorean expectation\n    .assign(wpc=lambda x: x['W'] / x['G'],\n           pyth=lambda x: x['R']**2 / (x['R']**2 + x['RA']**2))\n)\n\nipl18_combo\n\n\n# In[152]:\n\n\nsns.relplot(x='pyth', y='wpc', data=ipl18_combo)\n\n\n# # Run a regression\n\n# In[154]:\n\n\npyth_lm = smf.ols(formula = 'wpc ~ pyth', data=ipl18_combo).fit()\npyth_lm.summary()\n\n\n# Interpretation\n# \n# * pyth \n#     * coef = 2.5\n#     * std err = 2.077\n#     * t value = 1.235\n#     * P-value = 0.263 >> 0.05\n#     * P-value = probability that we'd observe the value 2.5 (for the coef) by chance if the true value were 0\n#     * p-values > 0.05, so values are not considered statistically significant.\n#         We have no confidence in this relationship.\n#     * R^2 is low (20%)\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "7a6744cacf8fafec05eebb34f0c2e20a14a4c1c5", "size": 5958, "ext": "py", "lang": "Python", "max_stars_repo_path": "notebooks/02-pythagorean-expectation-ILB-cricket.py", "max_stars_repo_name": "bartev/sporty", "max_stars_repo_head_hexsha": "3f134ba76f4fc55382ea5a598fe9438ecd87ea8d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/02-pythagorean-expectation-ILB-cricket.py", "max_issues_repo_name": "bartev/sporty", "max_issues_repo_head_hexsha": "3f134ba76f4fc55382ea5a598fe9438ecd87ea8d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "notebooks/02-pythagorean-expectation-ILB-cricket.py", "max_forks_repo_name": "bartev/sporty", "max_forks_repo_head_hexsha": "3f134ba76f4fc55382ea5a598fe9438ecd87ea8d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 20.3344709898, "max_line_length": 111, "alphanum_fraction": 0.6230278617, "include": true, "reason": "import numpy,import statsmodels", "num_tokens": 1847, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.10521053950871516, "lm_q1q2_score": 0.05014120220728456}}
{"text": "'''\n13 - Customizing your pandas import\n\nThe pandas package is also great at dealing with many  of the  issues  you  will\nencounter when importing data as a data  scientist,  such  as comments occurring\nin flat files, empty lines and missing values. Note that missing values are also\ncommonly referred to as NA or NaN. To  wrap  up this chapter, you're now going to\nimport a slightly corrupted copy of the Titanic dataset titanic_corrupt.txt, which\n\n    - contains comments after the character '#'\n    \n    - is tab-delimited.\n\nInstructions:\n\n- Complete the `sep` (the pandas version of delim), comment and na_values arguments of\n  pd.read_csv(). comment takes characters that comments occur after in the file, which\n  in this case is '#'. na_values takes a list of strings to recognize as  NA/NaN,  in\n  this case the string 'Nothing'.\n\n- Execute the rest of the code to print the head of the resulting DataFrame and plot\n  the histogram of the 'Age' of passengers aboard the Titanic.\n'''\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Import matplotlib.pyplot as plt\nimport matplotlib.pyplot as plt\n\n# Assign filename: file\nfile = 'titanic_corrupt.txt'\n\n# Import file: data\ndata = pd.read_csv(file, sep='\\t', comment='#', na_values='Nothing')\n\n# Print the head of the DataFrame\nprint(data.head())\n\n# Plot 'Age' variable in a histogram\npd.DataFrame.hist(data[['Age']])\nplt.xlabel('Age (years)')\nplt.ylabel('count')\nplt.show()\n\n\n'''\ndata.head()\n---------------------------------------------------------------------------------------------------------\n      PassengerId  Survived  Pclass     Sex   Age  ...  Parch            Ticket    Fare  Cabin Embarked\n    0            1         0       3    male  22.0  ...      0         A/5 21171   7.250    NaN       S \n    1            2         1       1  female  38.0  ...      0          PC 17599     NaN    NaN      NaN\n    2            3         1       3  female  26.0  ...      0  STON/O2. 3101282   7.925    NaN        S\n    3            4         1       1  female  35.0  ...      0            113803  53.100   C123        S\n    4            5         0       3    male  35.0  ...      0            373450   8.050    NaN        S\n    \n    [5 rows x 11 columns]\n---------------------------------------------------------------------------------------------------------\n'''\n", "meta": {"hexsha": "f63b57adf85d0c140714272874d048e86ad9003c", "size": 2348, "ext": "py", "lang": "Python", "max_stars_repo_path": "14_Introduction to Importing Data in Python-(part-1)/01_Introduction and flat files/13_customizing-your-pandas-import.py", "max_stars_repo_name": "mohd-faizy/DataScience-With-Python", "max_stars_repo_head_hexsha": "13ebb10cf9083343056d5b782957241de1d595f9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2021-02-03T14:36:58.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-01T10:29:26.000Z", "max_issues_repo_path": "14_Introduction to Importing Data in Python-(part-1)/01_Introduction and flat files/13_customizing-your-pandas-import.py", "max_issues_repo_name": "mohd-faizy/DataScience-With-Python", "max_issues_repo_head_hexsha": "13ebb10cf9083343056d5b782957241de1d595f9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "14_Introduction to Importing Data in Python-(part-1)/01_Introduction and flat files/13_customizing-your-pandas-import.py", "max_forks_repo_name": "mohd-faizy/DataScience-With-Python", "max_forks_repo_head_hexsha": "13ebb10cf9083343056d5b782957241de1d595f9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-02-08T00:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-17T13:52:32.000Z", "avg_line_length": 39.1333333333, "max_line_length": 105, "alphanum_fraction": 0.5587734242, "include": true, "reason": "import numpy", "num_tokens": 584, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.476579651063676, "lm_q2_score": 0.10521052758479321, "lm_q1q2_score": 0.050141196524586006}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# In[1]:\n\n\nimport numpy as np\nimport panel as pn\n\npn.extension(\"katex\")\n\n\n# # Lecture 08 - Wells*\n# \n# (_The contents are based on the class lecture materials of Prof. R. Liedl. Modifications mostly to fit this specific format were done by Prof. Liedl and Dr. P. K. Yadav._)\n# \n# ---\n# \n# ## Motivation\n# \n# In the last lecture ({doc}`/contents/flow/lecture_07/17_quantify_flow` we derived system equations for different groundwater flow problems. We realized of the difficulties associated with solving flow problems specially at higher dimensions (2D/3D). Numerical methods are mostly used for solving groundwater problems but direct (analytical) solutions are also possible for some problems. \n# \n# **Wells** are the most common and also most extensively used method of utilizing (or affecting) groundwater. Thus, _wells_ represent a very common groundwater problem. We can now use our understanding of aquifer properties and groundwater system equations to analyze effect of _wells_ on the natural groundwater flow. We will however restrict our extent, in this lecture, to problems that can be directly solved. After learning numerical methods (in last part of this course), we will apply it to evaluate more complex groundwater problems also associated with wells.\n# \n# We begin this lecture recalling groundwater storage property _transmissivity._ Introducing _wells_ we then derive few relations that can help us understand the effect of wells in groundwater flow. To conclude, we will use the _wells_ to characterize aquifers, i.e., using so called pumping test.\n# \n# (**_The contents are based on the class lecture materials of Prof. R. Liedl. Modifications mostly to fit this specific format were done by Prof. Liedl and Dr. P. K. Yadav._**)\n\n# ## Transmissivity ##\n# \n# When discussing storage properties in {doc}`/contents/flow/lecture_03/13_gw_storage`, we saw that aquifers or single layers may frequently be treated as two-dimensional systems. This is justified because the lateral extension of aquifers is usually much larger than the vertical extension. Thus, vertical variations of storage properties can be replaced by some average value without adversely affecting the quantification of groundwater storage.\n# \n# Similar things can be done with regard to conductivity properties and this brings us to the geohydraulic parameter of transmissivity ($T$,  L$^2$T$^{-1}$). The idea is to neglect vertical variations of hydraulic conductivity and to use vertically averaged values instead. This procedure does not eliminate horizontal variability, so transmissivity may still depend on horizontal coordinates  $(x, y)$.\n# \n# The vertically averaged $K$ value is then multiplied by the water-saturated thickness to obtain transmissivity. The concept of water-saturated thickness (or water-saturated depth) requires to distinguish whether _confined_ or _unconfined flow_ conditions prevail.\n# \n# In general, water-saturated thickness is the distance from the aquifer bottom to a level up to which all pores are filled with water. For _confined aquifers,_ this level is equal to aquifer top and water-saturated thickness is tantamount to aquifer thickness. For _unconfined aquifers,_ however, water-saturated thickness corresponds to the distance between aquifer bottom and groundwater level. We will see some illustrations below when we try to quantify transmissivity.\n# \n# Let us have a closer look at the confined case first. The black cuboid in {numref}`Trans_c_2D`  illustrates that water-saturated thickness extends from aquifer bottom to aquifer top. So, it is equal to aquifer thickness $m$. Transmissivity is calculated by $T_x = K_x \\cdot m$ and $T_y = K_y \\cdot m$. Here we allow for horizontal aquifer anisotropy with different hydraulic conductivities in $x-$ and $y-$ direction $(K_x\\neq K_y)$. For horizontally isotropic aquifers $(K_x = K_y = K)$, transmissivity is given by $T = K \\cdot m$.\n# \n# ```{figure} images/L08_f1.png\n# ---\n# scale: 40%\n# align: center\n# name: Trans_c_2D\n# ---\n# The transmissivity cuboid in confined aquifer.\n# ```\n# Things are a bit more complicated for unconfined aquifers.  {numref}`Trans_u_2D` illustrates that water-saturated thickness extends from the aquifer bottom to the groundwater table. It is important to note that transmissivity of unconfined aquifers depends on the vertical position of the groundwater table. For instance, if the groundwater table is lowered during to a draught period, transmissivity is decreasing. This is fundamentally different from the confined case where the water-saturated thickness is given by aquifer geometry only and is not affected by hydraulic head changes.\n# \n# ```{figure} images/L08_f2.png\n# ---\n# scale: 40%\n# align: center\n# name: Trans_u_2D\n# ---\n# The transmissivity cuboid in unconfined aquifer.\n# ```\n# \n# Computing transmissivity of unconfined aquifers requires to determine the difference of hydraulic head h and the elevation of aquifer bottom $z_{bot}$. Based on this, transmissivity is given by $T_x = K_x\\cdot(h - z_{bot})$ and $T_y = K_y\\cdot(h - z_{bot})$. As above, we are allowing for horizontal aquifer anisotropy. For an isotropic unconfined aquifer we get $T = K\\cdot(h - z_{bot})$.\n\n# Two more remarks appear to be appropriate: First, transmissivity may be computed by the given equations even if the aquifer bottom is not horizontal. This case is not covered by the {numref}`Trans_u_2D`. Second, textbooks frequently present the equation **$T = K\\cdot h$** for transmissivity of unconfined aquifers. It is to be noted that this equation only holds if two conditions are fulfilled: \n# \n# ```{admonition} Required conditions when $T = K\\cdot h$ is valid\n# :class: note\n# 1. The aquifer bottom must be horizontal, and \n# \n# 2. hydraulic head values are expressed with respect to the elevation of aquifer bottom (= reference datum).\n# ```\n# Finally, we can try to compute transmissivity for isotropic aquifers and check how the result depends on several quantities like aquifer bottom, aquifer top, and hydraulic head.\n\n# ### Example problem  ###\n# \n# ```{admonition} Transmissivity\n# Find if the aquifer is confined or unconfined, and then calculate transmissivity of the aquifer.\n# ```\n\n# In[2]:\n\n\n#print(\"\\n\\033[1m Provided are:\\033[0m\\n\") # \\033[1m \\033[0m bold font, \\n - new line\n\nK_a = 8.5e-05 # m/s, Hydraulic conductivity \nZ_bot = 120 # m, aquifer bottom \nZ_top = 150 # m, aquifer top\nh_a   =  139 # m, hydraulic head in aquifer\n\n# interim calculation\nA_t = Z_top-Z_bot # m, Aquifer thickness\nA_wt = h_a - Z_bot # m, water_table level\nS_t = min(A_t, A_wt) # m, saturated thickness\n\n# result\nif h_a<Z_top:\n    print(\"It is Unconfined Aquifer \\n\") \nelse: \n    print(\"It is Confined Aquifer \\n\") \n\nT_a = K_a*S_t # m^2/s, transmissivity\n\nprint(\"The required transmissivity is {0:1.2e}\".format(T_a), \"m\\u00b2/s\")\n\n\n# ## Wells - Overview ##\n# \n# ### What is a Well? ###\n# \n# A **well** is a shaft or a hole that has been sunk, dug or drilled into the earth to extract water (source: [Glossary of Hydrology](https://hydrologie.org/glu/HINDEN.HTM)).\n# \n# ```{figure} images/L08_f3.png\n# ---\n# scale: 50%\n# align: center\n# name: Well\n# ---\n# Well and its components.\n# ```\n# \n# ### Using wells ###\n# \n# Wells are very extensively used around the globe. The contents below only highlights few of the use of wells.\n# \n# ```{margin} \n# <img src=\" images/L08_f4.png\" alt=\"gw-sediment\" class=\"bg-primary\" width=\"300px\">\n# ```\n# \n# > Water supply: e.g., for households, agriculture, industry\n# \n# > Lowering the groundwater level: e.g., for excavations, open-pit mining\n# \n# > Remediation of aquifer contamination: e.g., applying pump and treat method.\n# \n# > Aquifer characterisation: e.g., using pumping test (this lecture)\n# \n# Apart from aquifer characterisation, wells are usually operated at steady-state i.e., at constant pumping rate. The figure below presents different uses of wells. {numref}`Well-ex` shows the case of lowering the groundwater level at the excavation site. The lowering is very often observed at the works that requires sub-surface construction works, e.g., high-rise building, tunnels. For this wells are placed close to excavation works and water is pumped out at higher discharge rates compare to the groundwater replenishing rate. This leads to decline of water level at the excavation site.\n# \n# ```{figure} images/L08_f5.png\n# ---\n# scale: 40%\n# align: center\n# name: Well-ex\n# ---\n# Well at the excavation site\n# ```\n# \n# {numref}`Well-refuse` presents the case of using wells to delineate contamination site from the groundwater. These are part of the development of sanitary landfills sites or industries that pose threat to groundwater quality. Wells are used to lower groundwater table such that seepage of refuse is contained in the limited region.\n# \n# ```{figure} images/L08_f6z.png\n# ---\n# width: 30 cm\n# height: 8 cm\n# align: center\n# name: Well-refuse\n# ---\n# Well at the refuse site\n# ```\n\n# ### Fully versus Partially Penetrating Wells ###\n# \n# Fully penetrating wells:\n# : The fully penetrating wells are those which extends through the whole saturated depth of an aquifer and are constructed in such a manner that water is permitted to the well screen over its length [Glossary of Hydrology](https://hydrologie.org/glu/HINDEN.HTM)). \n# \n# {numref}`full-pen` shows a schematic of water flow in a fully penetrating wells. \n# \n# ```{figure} images/L08_f7x.png\n# ---\n# scale: 40%\n# align: center\n# name: full-pen\n# ---\n# Flownet in a fully penetrating wells\n# ```\n# \n# Partially penetrating Wells:\n# : The partially penetrating Wells are those in which the length of water entry is less than the thickness of the saturated aquifer which it penetrates ([Glossary of Hydrology](https://hydrologie.org/glu/HINDEN.HTM)). \n# \n# Partially penetrating wells are constructed when aquifer depths are very high; in which case a fully penetrating well may not also be economical. {numref}`par-pen` presents a schematic of a flownet that is likely to be observed in the partially penetrating well.\n# \n# ```{figure} images/L08_f7y.png\n# ---\n# scale: 40%\n# align: center\n# name: par-pen\n# ---\n# Flownet in a partially penetrating wells\n# ```\n# \n# Comparing the Flownets in {numref}`full-pen` and {numref}`par-pen`, it can be observed that the vertical flow components can be significant in the partially penetrating case. This then lead to a 3D groundwater problem compared to the fully penetrating case, which can be treated as 2D groundwater problem as vertical flow component has limited effect.  \n# \n# This course we will deal only with the fully penetrating steady-state cases.\n# \n\n# ## Groundwater Flow Near Wells Operated at Steady State ## \n# \n# As stated earlier wells are mostly operated under steady-state condition. Here will attempt to quantify the case. We will first attempt to identify the most relevant problems associated with the steadily pumping wells and then define our approach to solve them. The **two** most important points that need to be addressed here  are:\n# \n# > Which relevant quantities are needed to describe steady-state flow\n# towards a well?\n# \n# > What is the quantitative relationship between the hydraulic\n# parameters under steady-state conditions?\n# \n# To answer the above questions, we follow the following approach:\n# \n# > Find an appropriate way to apply the _law of continuity_\n# (conservation of volume) and _Darcy‘s law._\n# \n# > We delineate the problem, e.g., study the _confined_ and the _unconfined_ cases separately.\n# \n\n# ### Cone of Depression in a Confined Aquifer ###\n# \n# A **cone of depression** (or drawdown cone) will result when the well pumps groundwater groundwater is pumped from the well. {numref}`cone-con-un` presents the schematic with relevant quantities of a well pumping case in both confined and unconfined aquifers. In both cases the well is fully penetrating. As can be understood from the figure that in the unconfined case the drawdown ($s$) magnitude depends on the water table level. This in the case of confined aquifer is dependent on the hydraulic head.\n# \n# \n# ```{figure} images/L08_f8-9.png\n# ---\n# scale: 25%\n# align: center\n# name: cone-con-un\n# ---\n# Cone of depression in a (a) confined Aquifer and (b) unconfined aquifer (right)\n# ```\n# \n# ```{margin} Relevant quantities in the figure:\n# + pumping rate $Q$ [L$^3$T$^{-1}$]\n# % free space\n# + aquifer thickness $m$ [L]\n# % free space\n# + hydraulic conductivity $K$ [LT$^{-1}$]\n# % free space\n# + water level at rest $H$ [L]\n# % free space\n# + water-level in the well $h$ [L]\n# % free space\n# + Radius of influence $R$ [L]\n# % free space\n# + well radius $r_w$ (incl. gravel pack!)[L]\n# % free space\n# + drawdown $s = H - h$ [L]\n# ```\n# \n# The Radius of influence ($R$) in the figure is the distance from the well at which the drawdown becomes negligible or unobservable. Thus $R$ delineates the influence of the well on the normal groundwater flow. \n# \n# #### Evolution of Cone of Depression with Time ####\n# \n# Transient models have to be used to observe the evolution of cone of depression. These are mostly only possible through use of numerical models (to be discussed in the later end of this course). The animation provides the computer simulation of evolving cone of depression as a function of time. From the figure it is easier to obtain the radius of influence ($R$). It is to be noted that $R$ will be maximum at the steady-state condition. \n\n# In[3]:\n\n\nvideo1 = pn.pane.Video(\"images/L08_f9X.mp4\", width=400, height=150, loop=False)\nspacer = pn.Spacer(width=50)\nimage = pn.pane.PNG(\"images/L08_f9Y.png\", width=200)\npn.Row(video1, spacer, image)\n\n\n# ### Law of Continuity ###\n# \n# Next we attempt to quantify the cone of depression. For this, and it is common in any hydraulics study, we begin with the _Law of Continuity._ Overall law of continuity implies:\n# \n# ```{admonition} Law of Continuity\n# Discharge $Q_w = $ constant\n# ```\n# \n# ```{figure} images/L08_f10X.png\n# ---\n# scale: 40%\n# align: center\n# name: law-cont\n# ---\n# Graphic visualization of Law of quantity.\n# ```\n# \n# This, also seen in {numref}`law-cont`, implies that the pumping rate $Q$ corresponds to the discharge $Q_w$ near the well. Further, under steady-state conditions the law of continuity\n# implies that there is the same discharge at all cross sections which\n# completely surround the well (\"mantle of a cylinder\").\n# \n# ### Darcy's Law for Flow Towards a Well in a Confined Aquifer ###\n# \n# The Darcy's law, as we have known so far,  relates the Darcy's velocity $v_f$ and the hydraulic gradient $i$. If the hydraulic gradient was constant in space, the hydraulic gradient would be (also see {numref}`law-cont` )\n# \n# $$\n# i = \\frac{\\Delta h}{\\Delta r}\n# $$\n# \n# where, $r$ represents the radial distance from the well axis. In this case the hydraulic gradient $i$ depends on the distance $r$ within a cone of depression {numref}`law-cont`). Qualitatively, it can be understood that $i$ is decreasing with increasing distance from the well. Since the hydraulic gradient is not constant in space, the ratio $\\frac{\\Delta h}{\\Delta r}$ has to be replaced by\n# \n# $$\n# i(r) = \\frac{\\textrm{d} h (r)}{\\textrm{d} r} \\tag{C1}\n# $$\n# \n# With this defined, the Darcy's law should be expressed as function of $r$ as\n# \n# $$\n# v_f (r) = - K\\cdot i(r) = - K \\cdot \\frac{\\textrm{d} h (r)}{\\textrm{d} r} \\tag{C2}\n# $$\n# \n# And, now introducing the continuity equation we obtain:\n# \n# $$\n# Q_w = A\\cdot v_f (r) = - K\\cdot i(r) = - K \\cdot A\\cdot\\frac{\\textrm{d} h (r)}{\\textrm{d} r} \\tag{C3}\n# $$\n# \n# with $A$ is the area of a cross section at distance $r$ from the well axis. Therefore $A$ is\n# \n# $$\n# A = 2\\cdot \\pi \\cdot r \\cdot m \\tag{C4}\n# $$\n# \n# $A$ is now inserted to eq. (C3), This results to\n# \n# $$\n# Q_w =  - 2\\cdot \\pi \\cdot r \\cdot m \\cdot K \\cdot \\frac{\\textrm{d} h (r)}{\\textrm{d} r} \\tag{C5}\n# $$\n# \n# ```{margin} \n# <img src=\"images/L08_f8.png\" alt=\"Confined Aquifer\" class=\"bg-primary\" width=\"400px\">\n# ```\n# \n# Eq (C5) is a first-order differential equation for hydraulic head $h(r)$. It can be solved by separation of variable. Doing that eq. (C5) becomes\n# $$\n# \\textrm{d}h(r) = \\frac{Q_w}{2\\cdot \\pi \\cdot m \\cdot K }\\cdot \\frac{\\textrm{d}r}{r} \\tag{C6}\n# $$\n# \n# We now integrate eq. (C6). The limit of integration (see figure) along the vertical direction ($h$) will be from $h$ to $H$, and that along the radial axis will be from $r_w$ and $R$, i.e., we get\n# \n# $$\n# \\int\\limits_h^H\\textrm{d}h(r) = \\frac{Q_w}{2\\cdot \\pi \\cdot m \\cdot K }\\cdot \\int\\limits_{r_w}^R\\frac{\\textrm{d}r}{r} \\tag{C7}\n# $$\n# \n# The integrals in eq. (C7) are direct integrals and can be obtained from the table of integrals. The eq. (C7) with the indefinite integrals is thus\n# \n# $$\n# \\big[h(r)\\big]_h^H = - \\frac{Q_w}{2\\cdot\\pi\\cdot m \\cdot K}\\cdot \\big[\\ln r\\big]_{r_w}^R \n# $$\n# \n# after inserting the limits of integration, we get\n# \n# $$\n# H - h = - \\frac{Q_w}{2\\cdot\\pi\\cdot m \\cdot K}\\cdot (\\ln R - \\ln r_w) \\tag{C8}\n# $$\n# \n# Finally, we can solve for the discharge $Q_w$ and obtain\n# \n# $$\n# Q_w = - \\frac{2\\cdot\\pi\\cdot m \\cdot K \\cdot (H-h)}{(\\ln R - \\ln r_w)}\\tag{C9}\n# $$\n# \n# The **negative** sign on the right-hand side of eq. (C9) indicates that flow is anti-parallel to the direction of the coordinate axis. Frequently, the pumping rate $Q$ is used instead of $Q_w$ and the negative sign is omitted. Thus we get a well known solution called Theim equation after Thiem (1906)<sup>[^Theim]</sup>\n# \n# ````{panels}\n# :container: container pb-4\n# :column: col-lg-8 p-2\n# \n# **The discharge from the well in confined aquifer after Thiem (1906)**\n# ^^^\n# $$\n# Q = \\frac{2\\cdot\\pi\\cdot m \\cdot K \\cdot (H-h)}{(\\ln R - \\ln r_w)}  =  \\frac{2\\cdot\\pi\\cdot m \\cdot K \\cdot (H-h)}{\\ln (R/r_w)}\n# $$\n# ````\n# \n# with decadic logarithm, we get,\n# \n# $$\n# Q_w = \\frac{2\\cdot\\pi\\cdot m \\cdot K \\cdot (H-h)}{2.3\\cdot(\\log R - \\log r_w)}  =  \\frac{2\\cdot\\pi\\cdot m \\cdot K \\cdot (H-h)}{2.3 \\cdot\\log (R/r_w)}\n# $$\n# \n# [^Theim]: Thiem, G. (1906), _Hydrologische Methoden_, 56 pp., Gephardt, Leipzig, Germany.\n\n# ### Example problem  ###\n# \n# ```{admonition} Well discharge from confined aquifer\n# From the provided data, calculate the transmissivity of the aquifer.\n# ```\n\n# #### Solution ####\n# \n# For confined aquifer $T = K\\cdot m$, the Thiem equation can be modified as:\n# \n# $$\n# Q = \\frac{2\\cdot\\pi\\cdot T \\cdot (H-h)}{\\ln (R/r_w)}\n# $$\n\n# In[4]:\n\n\nprint(\"\\n\\033[1m Provided are:\\033[0m\\n\")\n\nQ = 9 # m^3/min, Given discharge\nr1 = 8 # m, distance from well to point 1\nh1 = 9 # m, head at well 1\nR2 = 22 # m, distance from well to point 2\nH2 = 10 # m, head at well 2\n\nprint(\" The given dscharge is: {}\".format(Q), \"m\\u00b3/min \\n\")\nprint(\" The distance to Well 1 and well 2 are: {}m and {}m  \\n\".format(r1, R2))\nprint(\" The head at Well 1 and well 2 are: {}m and {}m\".format(h1, H2))\n\n#interim calculation \nQ_min = Q * 1440 # m^3/d\n\n#Calculation\n\nT = Q/(2*np.pi*(H2-h1))*np.log(R2/r1) # m^2/d, Transmissivity - inverting Theim equation\n\nprint(\"\\n\\033[1m Result:\\033[0m\\n\")\nprint(\"The transmissivity in the aquifer is {0:0.2f} m\\u00b2/d\".format(T)) \n\n\n# ## Flow Towards a Well in an Unconfined Aquifer ##\n# \n# In the unconfined aquifer, the hydraulic head is function of $r$. Thus the discharge in the aquifer:\n# \n# $$\n# Q_w = A \\cdot v_f = - A \\cdot K \\frac{\\textrm{d}h}{\\textrm{d}r}(r) \\tag{U1}\n# $$\n# \n# ```{margin} \n# <img src=\"images/L08_f9.png\" alt=\"Unconfined Aquifer\" class=\"bg-primary\" width=\"400px\">\n# ```\n# Also in this case, the cross section area $A$ also is dependent on $r$, i.e.,\n# \n# $$\n# A = 2 \\cdot \\pi \\cdot r \\cdot h(r) \\tag{U2}\n# $$\n# \n# Next, we insert eq (U2) in eq. (U1) and get\n# \n# $$\n# Q_w = A \\cdot v_f = - 2 \\cdot \\pi \\cdot r \\cdot h(r)  \\cdot K \\frac{\\textrm{d}h}{\\textrm{d}r}(r) \\tag{U3}\n# $$\n# \n# Eq. (U3) is a first-order differential equation for hydraulic head $h(r)$, and it can be solved by separation of variables. Separating the variables of eq. (U3) leads to\n# \n# $$\n# h(r) \\cdot \\textrm{d}h(r) = - \\frac{Q_w}{2 \\cdot \\pi \\cdot K }\\cdot \\frac{\\textrm{d}r}{r} \\tag{U4}\n# $$\n# \n# Next we integrate eq. (U4) from limits $r_w$ to $R$ in the right-hand side, and from $h$ to $H$ (left-hand side), i.e.,\n# \n# $$\n# \\int\\limits_h^H h(r) \\cdot \\textrm{d}h(r) = - \\frac{Q_w}{2 \\cdot \\pi \\cdot K }\\cdot \\int\\limits_{r_w}^{R}\\frac{\\textrm{d}r}{r} \\tag{U5}\n# $$\n# \n# The integral in eq. (U5) can be obtained from the standard table of integrals. With that we get\n# \n# $$\n# \\frac{1}{2}(H^2 - h^2) = - \\frac{Q_w}{2 \\cdot \\pi \\cdot K }\\cdot (\\ln R - \\ln r_w) \\tag{U6}\n# $$\n# \n# The discharge in aquifer $Q_w$ can be obtained from eq. (U6) and the expression is\n# \n# $$\n# Q_w = -\\frac{\\pi\\cdot K \\cdot (H^2-h^2)}{\\ln R - \\ln r_w}\\tag{U6}\n# $$\n# \n# The negative sign on the right-hand side of the eq. (U6) indicates that flow is anti-parallel to the orientation of the coordinate axis. Frequently, the pumping rate $Q$ is used instead of $Q_w$ and the negative sign can thus be \n# omitted, and we get\n# \n# ````{panels}\n# :container: container pb-4\n# :column: col-lg-10 p-2\n# \n# **Discharge $Q$ from well in unconfined aquifer modified from Thiem (1906)**\n# ^^^\n# $$\n# Q_= \\frac{\\pi\\cdot K \\cdot (H^2-h^2)}{\\ln R - \\ln r_w} = \\frac{\\pi\\cdot K \\cdot (H^2-h^2)}{\\ln (R/r_w)}\n# $$\n# ````\n# \n# In the decadic logarithm, the discharge from the well is:\n# \n# $$\n# Q_= \\frac{\\pi\\cdot K \\cdot (H^2-h^2)}{2.3(\\log R - \\log r_w)} = \\frac{\\pi\\cdot K \\cdot (H^2-h^2)}{2.3\\log (R/r_w)}\n# $$\n\n# ### Example problem  ###\n# \n# ```{admonition} Well discharge from unconfined aquifer\n# From the provided data, calculate discharge of the aquifer.\n# ```\n\n# In[5]:\n\n\nprint(\"\\n\\033[1m Provided are:\\033[0m\\n\")\n\nK = 24.50 # m/d, conductivity\nr_1 = 0.23 # m, distance from well to point 1\nh_1 = 12 # m, head at well 1\nR_2 = 275 # m, distance from well to point 2\nH_2 = 18 # m, head at well 2\n\nprint(\" The given conductivity is: {}\".format(K), \"m/d \\n\")\nprint(\" The distance to Well 1 and well 2 are: {} m and {} m are \\n\".format(r_1, R_2))\nprint(\" The head at Well 1 and well 2 are: {} m and {} m\".format(h_1, H_2))\n\n#Calculation\n\nQ_1 = (np.pi*K*(H_2**2-h_1**2))/(np.log(R_2/r_1)) # m^2/d, Transmissivity - inverting Theim equation\n\nprint(\"\\n\\033[1m Result:\\033[0m\\n\")\nprint(\"Discharge from the well is {0:0.2f} m\\u00b3/d\".format(Q_1)) \n\n\n# ### Radius of Influence ### \n# \n# The radius of influence ($R$) can also (instead of using numerical simulations) be obtained from empirical equations. The table below provides a list of few equations.\n# \n# ```{margin} The symbols in equations are:\n# + $s$ = drawdown in pumping well, \n# + $t$ = pumping time, \n# + $N$ = groundwater recharge, \n# + $S$ = storage coefficient, \n# + $K$ = hydraulic conductivity, \n# + $H$ = water level at rest (unconfined aquifer).\n# \n# In confined aquifers, $H$ has to be replaced by the aquifer thickness $m$.\n# ```\n# \n# | Source                             |   | Equation                                  |\n# |------------------------------------|---|-------------------------------------------|\n# | Lembke (1886, 1887)                |   | $R = H (K/2\\cdot N)^{1/2}$                |\n# | Weber (Schultze, 1924)             |   | $R = 2.45 (H\\cdot K\\cdot t/S)^{1/2}$      |\n# | Kusakin (Aravin and Numerov, 1953) |   | $R = 1.9 (H \\cdot K \\cdot t/s)^{1/2}$     |\n# | Siechardt (Certousov, 1962)        |   | $R = 3000\\cdot s \\cdot K^{1/2}$           |\n# | Kusakin (Certousov, 1949)          |   | $R = 575\\cdot s \\cdot (H \\cdot K)^{1/2} $ |\n# \n# \n# **Siechardt** and **Kusakin** equation are among the preferred equations by practitioners. In both equations, $K$ has to be expressed in _m/s_ and all other quantities must be expressed in _m._ _R_ depends on drawdown $s= H-h$ in both equations. Trial and error or iterative strategies have to be used to determine $R$ and $h$.\n# \n# \n\n# ## Aquifer Characterisation by Pumping Tests ## \n# \n# Pumping tests are used to estimate aquifer properties such as hydraulic conductivity $(K)$, transmissivity $(T)$ or storativity $(S)$. Pumping results in an evolving cone of depression as was discussed earlier (see {numref}`cone-con-un`). The decrease in hydraulic head (or increase in drawdown) with time is recorded in one or more observation wells (and sometimes also in the pumping well itself).\n# \n# ```{margin}\n# <img src=\"images/L08_f13.png\" alt=\"Theis\" class=\"bg-primary\" width=\"200px\">\n# ```\n# \n# A variety of different schemes exist to evaluate pumping test data. The appropriate method has to be selected according to the specific setting (confined or unconfined, layered system, horizontal or inclined aquifer bottom etc.). A well known approach to derive $T$ and $S$ from pumping test data was developed by Theis (1935)<sup>[^Theis]</sup>\n# \n# ### Applicability of the Theis Method ###\n# \n# Pumping test data can be evaluated according to Theis (1935) if the following assumptions are (approximately) justified: \n# \n# + The aquifer is confined, homogeneous and isotropic.\n# %\n# + The aquifer thickness is uniform.\n# %\n# + The aquifer bottom is horizontal.\n# %\n# + The well is fully penetrating.\n# %\n# + The well radius is very small as compared to the radius of influence.\n# %\n# + The pumping rate is constant within the measurement period.\n# %\n# + There is no vertical flow component.\n# %\n# + The evolution of the cone of depression is not influenced by other hydraulic factors (surface water, impermeable boundaries etc.). \n# \n# [^Theis]: Theis, C.V., 1935. The relation between the lowering of the piezometric surface and the rate and duration of discharge of a well using groundwater storage, Am. Geophys. Union Trans., vol. 16, pp. 519-524.\n\n# ### Drawdown According to Theis (1935) ###\n# \n# Theis (1935) deals with the transient flow (as opposed to steady-state methods discussed above) of water to a pumping well. The time-dependent drawdown $s$ in an observation well, which is a distance $r$ apart from the pumping well, is given by\n# \n# ```{margin}\n# + $s$ is drawdown [L]\n# %\n# + $Q$ is pumping rate [L$^3$T$^{-1}$]\n# %\n# $T$ is transmissivity [L$^2$T$^{-1}$]\n# %\n# $W(u)$ is the well function\n# ```\n# \n# $$\n# s(r,t) = \\frac{Q}{4\\pi T}\\cdot W(u) \\tag{T1}\n# $$\n# \n# where, $W(u)$ is the well function, which is given as\n# \n# $$\n# W(u) = \\int\\limits_u^\\infty \\frac{\\textrm{e}^{-\\widetilde{u}}}{\\widetilde{u}}\\textrm{d}\\widetilde{u}\n# $$\n# \n# in which $u$ is defined by\n# \n# $$\n# u = \\frac{Sr^2}{4Tt} \\tag{T2}\n# $$\n# \n# where $S$ [-] is storage coefficient. For application Eq (T1) and eq. (T2), these equation are log-transformed. Eq (T1) then becomes\n# \n# $$\n# \\log s(r,t) = \\log \\frac{Q}{4\\pi T}\\cdot \\log W(u) \\tag{T3}\n# $$\n# \n# and upon log-transformation and rearrangement of eq. (T2) results to\n# \n# $$\n# \\log \\frac{t}{r^2} = \\log\\frac{S}{4T} + \\log\\frac{1}{u} \\tag{T4}\n# $$\n# \n# These two equations are used to derive $T$ and $S$ from drawdown data. This can either be done by applying special computer software or manually by a graphical method, which is discussed next.\n# \n\n# ### Manual Comparison of Data and Type Curve ### \n# \n# Theis (1935) provides a graphical approach to use the  Theis equation. The following steps are to be followed for using the graphical approach:\n# \n# + The logarithm of drawdown ($\\log s$) is plotted against the $\\log(t/r^2)$ in the data sheet\n# \n# + The logarithm of the well function $(\\log W(u))$ is plotted against $\\log (1/u)$ in a type curve sheet. \n# \n# ```{sidebar} Type Curve and Data sheet\n# <img src=\"images/L08_f11.png\" alt=\"Type-Curve\" class=\"bg-primary\" width=\"1000px\">\n# ```\n# \n# + Both sheets are put on top of each other such that the data coincide with some part of the type curve.\n# \n# + The shifts along the vertical and the horizontal axes correspond to the constant terms in the equations\n# \n# $$\n# \\log s = \\log\\frac{Q}{4\\cdot \\pi \\cdot T} + \\log W(u)\n# $$\n# \n# $$\n# \\log \\frac{t}{r^2} = \\log\\frac{S}{4 T} + \\log \\frac{1}{u} \n# $$\n# \n# + The constant term in the upper equation ($\\log\\frac{Q}{4\\cdot \\pi \\cdot T}$) can then be solved for $T$.\n# \n# + Finally, the constant term $(\\log\\frac{S}{4 T})$ in the lower equation can be used to solve for $S$.\n# \n# ```{important}\n# The Type curve is independent from aquifer properties.\n# ```\n\n# ### Example  ###\n# \n# ```{admonition} Using Type curve\n# For the provided pumping data, find the Transmissivity and Storage coefficient when the steady-discharge was 26.7 L/s.\n# ```\n\n# #### Solution ####\n# \n# The practical application of the Theis method is facilitated by selecting a match point in the range of the data such that corresponding values $W_A$\n# and $1/u_A$ are \"simple\".\n# \n# <img src=\"images/L08_f14.png\" alt=\"Type-Curve-Example\" class=\"bg-primary\" width=\"600px\">\n# \n# In the example:\n# \n# $$\n# W_A = 10^0 = 1\n# $$\n# \n# $$\n# 1/u_A = 10^2 = 100\n# $$\n# \n# Next, values for $s$ and $t/r^2$ at the match points are determined. In this example:\n# \n# $$\n# S = 0.2\n# $$\n# \n# $$\n# t/r^2 = 0.57\n# $$\n# \n# Next, we obtain $T$ from $T = \\frac{Q}{4\\cdot\\pi\\cdot s }\\cdot W_A$. For $Q = 26.7$ L/s, we obtain $T = 1.06 \\cdot 10^{-2} $ m<sup>2</sup>/s. Finally, $S$ is obtained from $S = \\frac{4 T\\cdot t/r^2}{1/u_A}$. In this example:\n# $S = 2.42 \\cdot 10^{-4}$\n\n# ### Computer-Based Comparison of Data and Type Curve ###\n# \n# The data in the type-curve can now easily be fitted using computer simulations. The {numref}`Type-Cur-com` is from the {doc}`/contents/tutorials/tutorial_07/tutorial_07`. The simulation tool {doc}`/contents/tools/type_curve_fit` provided can be used to fit user data to the type curve. \n# \n# ```{figure} images/L08_f15.png\n# ---\n# scale: 20%\n# align: center\n# name: Type-Cur-com\n# ---\n# Computationally fitted data to the Type curve\n# ```\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "b8ab95ddb12b5f09ea2ce375a66d3b25f390194c", "size": 29726, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/contents/flow/lecture_08/18_wells.py", "max_stars_repo_name": "prabhasyadav/iGW-I", "max_stars_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_build/jupyter_execute/contents/flow/lecture_08/18_wells.py", "max_issues_repo_name": "prabhasyadav/iGW-I", "max_issues_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/contents/flow/lecture_08/18_wells.py", "max_forks_repo_name": "prabhasyadav/iGW-I", "max_forks_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.5873925501, "max_line_length": 594, "alphanum_fraction": 0.6859651484, "include": true, "reason": "import numpy", "num_tokens": 8917, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.39233683016710835, "lm_q2_score": 0.12765262532179067, "lm_q1q2_score": 0.0500828263812609}}
{"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# In[1]:\n\n\nimport numpy as np\nimport pandas as pd \nimport matplotlib.pyplot as plt\nfrom xlrd import *\nimport ipysheet as ips\nimport panel as pn\nget_ipython().run_line_magic('matplotlib', 'inline')\nfrom scipy import stats \npn.extension('katex') \n\n\n# ## Groundwater Exam Solution -  2019-2020 ##\n# \n# _(The contents presented in this section were re-developed principally by Dr. P. K. Yadav with supervision from Prof. Rudolf Liedl)_\n\n# **Q1. Aquifer Types**   (ca. 5 pts.)\n# \n# \n# a. Differentiate between Aquifer, Aquitard and Aquiclude (3 points)\n# \n# b. Schematically present a confined aquifer (vertical cross-section) providing essential features with their legends (2 points)\n\n# **Solution 1. a.**\n# \n# See slide: L03/08\n# \n# An **aquifer** or a groundwater reservoir can store and transmit significant (= exploitable) amounts of groundwater.\n# \n# An **aquitard** can store and transmit groundwater but to a much lesser extent than an (adjacent) aquifer.\n# \n# An **aquiclude** can store groundwater but cannot transmit groundwater.\n# \n\n# **Solution 1b** - (L03/11)\n# \n# &nbsp;\n# \n# <img src=\"figs/Q1b_2019-20.png\" alt = \"Question 5\" class=\"bg-primary\" width =  \"1000px\"> \n# \n# **Confined Aquifer**\n# \n# 1. The essential feature of confined aquifer is provided in the figure above.\n# \n\n# **Q2. Groundwater storage (3 pts.)**\n# \n# Dry season in Dresden (2018-19) led to intense extraction of groundawater in rural areas. At one location in a confined aquifer (storage coeff. 4·10<sup>-4</sup>, total porosity = 30%),  the pressure head was lowered by 150 m. The thickness of the aquifer was measured to be 90 m before the beginning of extraction and the compressibility of the porous medium in that region is estimated 6·10<sup>-8</sup> m<sup>2</sup>/N. Density of water can be assumed to be 1000 kg/m<sup>3</sup>.\n# \n# (Hint: $\\Delta V_T = \\alpha_{pm}\\cdot\\rho_w \\cdot g \\cdot  V_T \\cdot  \\Delta \\psi $).\n# \n# \n# a. Approximately how much water was extracted? (1 point)\n# \n# b. How much land subsidence due to water extraction is expected? (2 point)\n# \n\n# **Solution 2**\n# \n# Given relation:\n# \n# For part a. (see Tut 02/P4)\n# \n# $\n# S_s  = \\frac{\\Delta V_w}{V_T\\cdot \\Delta \\psi}\n# $\n# \n# In confined aquifer $S$ is used, which is obtained from:\n# \n# $S = S_s \\cdot m$\n# \n# $\n#  \\frac{S}{m} = \\frac{\\Delta V_w}{A_T\\cdot m \\cdot \\Delta \\psi}\n# $\n# \n# So, \n# \n# $  \\frac{\\Delta V_w}{A}  = S \\cdot \\Delta \\psi$\n# \n# \n# For part b.\n# \n# \n# $\\Delta V_T = \\alpha_{pm}\\cdot\\rho_w \\cdot g \\cdot  V_T \\cdot  \\Delta \\psi $\n# \n# $V_T = A\\times h$, with $A$ surface area and $h$ aquifer thickness.\n# \n# $\\Delta V_T = A \\times \\Delta h$, with $\\Delta h$ change in thickness.\n# \n# $A \\times \\Delta h= \\alpha_{pm}\\cdot\\rho_w \\cdot g \\cdot  A \\cdot h \\cdot  \\Delta \\psi $\n# \n# $\\Delta h = \\alpha_{pm}\\cdot\\rho_w \\cdot g \\cdot h \\cdot  \\Delta \\psi$, with $\\Delta h$ being the land subsidence \n\n# In[2]:\n\n\n#  solution 2 a\n\n# Given\n\nA = 1 # m², assuming 1 m² aquifer area\nh = 90 # m, aquifer height before extraction\nd_psi = 150 # m, change in pressure head\nS_2 = 4*10**-4 #  specific storage\nrho_w = 1000 # Kg/m³, density of water\na_pm = 6* 10**-8 # m²/N = m-s²/kg, compressibility of porous medium\ng = 9.81 # m/s², gravity factor\n\n#Solution\n\nd_V_w  = S_2*A*d_psi\n\nprint(\"The water abstraction volume per m\\u00b2 aquifer is {0:0.3f}\".format(d_V_w), \"m\\u00b3\")\n\n\n# In[3]:\n\n\n#  solution 2 b\n\n\n# Given\n\nA = 1 # m², assuming 1 m² aquifer area\nh = 90 # m, aquifer height before extraction\nd_psi = 150 # m, change in pressure head\nSs = 4*10**-4 # specific storage\nrho_w = 1000 # Kg/m³, density of water\na_pm = 6* 10**-8 # m²/N = m-s²/kg, compressibility of porous medium\ng = 9.81 # m/s², gravity factor\n\n#interim calculation\nV_T = A*h # m³, Aquifer volume before extraction \n\n#Solution\n\nd_h  = a_pm*rho_w*g*h*d_psi\n\nprint(\"The water abstraction volume is {0:0.2f}\".format(d_h), \"m\")\n\n\n# **Q3. Aquifer Properties** (ca. 10 pts.)\n# \n# The hydraulic conductivity of a sample (length 15 cm, diameter 5 cm) is to be determined using a constant-head permeameter. For that 250 ml water is passed through the sample in 30 s while maintaining the head difference of 2.5 cm. Properties of water provided are:\n# density of water at 20°C: 1000 kg/m<sup>3</sup>;                                                  dynamic viscosity of water at 20°C: 1.0087·10<sup>-3</sup> Pa·s\n#        \n# a.  Sketch the problem as accurately as possible providing essential features with legends (3 points)\n# \n# \n# b. What will be the conductivity of the sample? (4 points)\n# \n# What is the intrinsic permeability of the sample? (2 points)\n# \n# c. What soil type is likely the sample? (1 point)\n# \n# (Hint: For the calculation of permeability, dynamic viscosity/density ratio is required.)\n#  \n# \n# \n\n# **Solution 3** - \n# \n# **Solution 3a** (L05/15)\n# \n# &nbsp;\n# \n# <img src=\"figs/Q3a_2019-20.png\" alt=\"Question 3a\" class=\"bg-primary\" width= \"500px\"> \n# \n\n# In[4]:\n\n\n#Solution 3b** (L05/15)\n\n# Given\n\nL_c = 15 # cm, column length\nDia_c = 5 # cm, diameter column\nV_in= 250 # mL, water entering the column\nt_c = 30 # s, time required to pass\nd_3h = 2.5 # cm, head difference\n\n# interim calculation\nA_c = np.pi*Dia_c**2/4 # cm², Area of column\nQ_c = V_in/t_c # cm³/s, assume 1mL = 1 cm³, Discharge out of column\n\n#solution \nK_c = (Q_c*L_c)/(A_c*d_3h) # cm/s, conductivity \n\n\nprint(\"The area of the column is {0:0.2f}\".format(A_c), \"cm\\u00b2\")\nprint(\"The discharge from the aquifer is {0:0.2f}\".format(Q_c), \"cm\\u00b3/s\")\nprint(\"The conductivity of the sample is {0:0.2f}\".format(K_c), \"cm/s\")\nprint(\"The conductivity of the sample is {0:0.4f}\".format(K_c/100), \"m/s\")\n\n\n# In[5]:\n\n\n#Solution 3c** (L05/18)\n\n# Given\n\nK_m = K_c/100 # m/s, conductivity\nrho_3w = 1000 # Kg/m³, density of water\nnu_w = 1.0087*10**-3 # Pa-s = Kg/m-s, dynamic viscosity \ng = 9.81 # m/s², gravity factor\n\n#solution\nk_c = K_m*nu_w/(rho_3w*g)\n\nprint(\"The permeability of the sample is {0:0.10f}\".format(k_c), \"m\\u00b2\")\nprint(\"The permeability of the sample is {0:0.2E}\".format(k_c), \"m\\u00b2\")\n\n\n# **Solution 3d**\n# (L05/11)\n# \n# The sample in the column is likely gravel or coarse sand.\n\n# **Q4. Sieve Analysis (ca. 6 pts.)**\n# \n# Sieve experiments were performed with the bore samples and the following observations were obtained: \n# \n# | mesh diameter [mm] \t| residue in the sieve [g] \t| Σ total \t| Σ/Σtotal \t|\n# |:------------------:\t|:------------------------:\t|:-------:\t|:--------:\t|\n# |          6         \t|             0            \t|         \t|          \t|\n# |          2         \t|            40            \t|         \t|          \t|\n# |         0.6        \t|            250           \t|         \t|          \t|\n# |         0.2        \t|            150           \t|         \t|          \t|\n# |        0.06        \t|            60            \t|         \t|          \t|\n# |     <0.06 (cup)    \t|            10            \t|         \t|          \t|\n# \n# \n# a. Draw the granulometric curve in the diagram below.\t\t\t(ca. 5 pts.)\n# \n# b. Briefly characterise the sediment.\t\t\t\t\t\t(ca. 1 pt.)\n\n# In[6]:\n\n\n#Solution 4 -(L03/18)\n\ndia = [6,2,0.6,0.2, 0.06, 0.001] # mm, diameter <0.06 (cup)= 0.001\nmass = [0, 40, 250, 150, 60, 10] # g, the residue in seive \n\n# Calculation steps - filling table\nTotal_mass = np.sum(mass)  # add the mass column to get total mass\nretain_per = mass/Total_mass*100   # retain percentage\nretain_per_cumsum = np.cumsum(retain_per) # get the cummulative sum of the reatined\npassing_per = 100 - retain_per_cumsum # substract 100-cummsum to get passing %\n\ndata = {\"mesh diameter [mm]\": dia, \"residue in the sieve [g]\": mass, \"Σtotal\": retain_per, \"Σ/Σtotal\": passing_per }\n\ndf1= pd.DataFrame(data)\ndf1 \n\n\n# In[7]:\n\n\n# plotting\nplt.rcParams['axes.linewidth']=2\n#plt.rcParams[\"axes.edgecolor\"]='white'\nplt.rcParams['grid.linestyle']='--'\nplt.rcParams['grid.linewidth']=1\nx = np.append([10],dia) # adding data to extend over 6 mm dia\ny = np.append([100],passing_per) # adding 100% to plot\n\nfig = plt.figure(figsize=(9,6))\nplt.semilogx(x, y, 'x-', color='red')  \ntics=x.tolist()\n\nplt.grid(which='major', color='k', alpha=0.7) \nplt.grid(which='minor', color='k', alpha=0.3)\nplt.xticks(x, tics);  \nplt.yticks(np.arange(0,110,10));\nplt.title('grain size distribution');\nplt.xlabel('grain size d [mm]');\nplt.ylabel('grain fraction < d ins % of total mass');\n\n\n# **solution 4b**\n# \n# The sample can be considered uniformly distributed as over 70% of sample falls in the sand size (0.2 mm-2 mm). Therefore, the sample can be considered sandy. \n\n# **Q5. Aquifer characterization** (ca. 8 pts.)\n# \n# Water levels in m a.s.l. were measured at three observation wells (see figure).\n# \n# \n# <img src=\"figs/Q5_2019-2020.png\" alt = \"Question 5\" class=\"bg-primary\" width = \"300px\"> \n# \n# a. Sketch hydraulic head isolines for increments of 0.5 m. (ca. 3 points.)\n# \n# b. Gravel layer (thickness (t1) = 1.5 m, and conductivity (K1) = 3.7 10-3 is embedded between two sandy layers (t2 = 2 m, K2 = 3·10-4 m/s; and t3 = 3 m, K3 = 4·10-4 m/s). If the hydraulic gradient is 1% and overall discharge is 1 m3/d per unit width of the aquifer, find the effective hydraulic conductivity considering a parallelly layered aquifer. \n# \n# (Hint: $K_{eff} = \\frac{m}{\\sum_{i=1}^n \\frac{m_i}{K_i}}$ or $K_{eff} =  \\sum_{i=1}^n\\frac{m_i\\cdot K_i}{m}$  ) (ca. 2 points)\n# \n# c. Distinguish between homogeneity and heterogeneity, and isotropy and anisotropy (ca. 3 points)  \n# \n# \n# \n\n# **Solution 5a**\n# (L07/08-09)\n# \n# The isolines and flow direction is provided in the figure below.\n# \n# \n# <img src=\"figs/Q5a_2019-2020.png\" alt = \"Question 5a\" class=\"bg-primary\" width =\"300px\"> \n\n# In[8]:\n\n\n# Solution 5b (L06/08-13)\n\n# Given:\n\nG_t1 = 2 # m, sandy layer top\nG_t2 = 1.5 # m, gravel layer middle\nG_t3 = 3 # m, sandy layer bottom \nK_1 =  3.0*10**-4 # m/s cond. in G_t1\nK_2 = 3.7*10**-3 # m/s cond. in G_t2\nK_3 =  4.0*10**-4 # m/s cond. in G_t3\ni = 1/100 # (), hydraulic gradient 1%\nQ_5 = 1 # m³/d per-W, discharge per unit width\n\n#intermediate calculation\nm = G_t1+G_t2+G_t3 # m, total aq. thickness\n\nK_ef_h = (1/m) * (G_t1*K_1 + G_t2*K_2 + G_t3*K_3) # m/s, eff. horizontal cond.\nK_ef_v = m/(G_t1/K_1 + G_t2/K_2 + G_t3/K_3) # # m/s, eff. vertical cond.\n\nprint(\"The thickness of the aquifer is {0:0.3f}\".format(m), \"m\")\nprint(\"The effective horizontal conductivity of the aquifer is {0:0.2E}\".format(K_ef_h), \"m/s\")\nprint(\"The effective vertical conductivity of the aquifer is {0:0.2E}\".format(K_ef_v), \"m/s\")\n\n\n# **Solution 5c** (L06/23) \n# \n# **Homogeneity**: An aquifer is homogeneous when its parameters are constant throughout the porous medium, i.e. the properties of the medium are independent of space\n# \n# **Heterogeneity**: Heterogeneous aquifer have its properties varies in space or the properties are space dependent.\n# \n# **Isotropy**: This relates to properties of aquifer being independent of direction, i.e., $K_v = K_h$ \n# \n# **Anisotropy**: In this case the aquifer properties are direction dependent, i.e., $K_v \\neq K_h$.\n\n# **Q6. Well** (ca. 5 pts.)\n# \n# \n# a. Sketch the pumping scenario of an unconfined aquifer (vertical cross section) and label all possible quantities (ca 3 pts.)\n# \n# \n# b. The conductivity of a confined aquifer (8 m thick) is estimated to be $4\\cdot 10^{-4}$ m/s. If the steady-state discharge 50 m<sup>3</sup>/s, using the Theis equation ($s = Q/4\\pi T·W(u)$, with $W(u) = 15$), find the drawdown in the aquifer. (2 points)\n# \n\n# **Solution 6a**\n# (L08/16)\n# \n# Figure below presents the scenario of a well in an _unconfined_ aquifer.\n# \n# \n# <img src=\"figs/Q6_2019-2020.png\" alt = \"Question 7b\" class=\"bg-primary\" width =\"500px\"> \n# \n\n# In[9]:\n\n\n#Solution 6b\n\n#Given\n\nQ_6 = 50 # m³/s, discharge\nK_6 = 4*10**-4 # m/s, conductivity\nm_6 = 8 # m, thickness\nW_u = 15 # (), well function\n\n# interim cal.\nT_6 = K_6 * m_6 # m²/s, Transmissivity T = K*m\n\n# solution\ns_6 = (Q_6/(4*np.pi*T_6)) * W_u # m, drawdown\n\nprint(\"The Transmissivity of the aquifer is {0:0.5f}\".format(T_6), \"m\\u00b2/s\")\nprint(\"The drawdown in the well is {0:0.2f}\".format(s_6), \"m\")\n\n\n# **Q7. Conservative Transport**  (ca. 7 pts.)\n# \n# a. How is reactive transport different to conservative transport in the aquifers. (2 points)\n# \n# b. With suitable sketch distinguish between advective flux and dispersive flux. (2 points)\n# \n# \n# c. A column (L = 1.2 m and Ø = 5 cm) was packed with sandy soil (ne= 35%  K= 0,0002 m/s). The hydraulic head at the inlet and the outlet was set to 230 m and 235 m, resp. The NaCl solution with conc. 10 mg/L was steadily introduced to the column after saturating it with distilled water. The experiment condition was such that diffusive flow could be neglected.  You may make justified assumption for any missing information.\n# \n# c.i. What will be the advective mass flux at the outlet of the column? (1.5 points)\n# \n# c.ii. Considering initial concentration difference between inlet and outlet to be 10 mg/L, what    will be the dispersive mass flux at the outlet? (1.5 points) \n# \n# (Hint: Dispersive and Advective fluxes are either of $ n_e \\cdot v\\cdot C$ and $n_e\\cdot \\alpha \\cdot v \\cdot \\Delta C/L$)\n\n# **Solution 7a** (L09/05) \n# \n# A chemical in groundwater is subject to conservative transport processes if there is:\n# \n# + no interaction with the solid material,   \n# + no interaction with other chemicals,                  \n# + no interaction with microbes.\n# \n# When either of the above are part of the groundwater, the transport process is reactive.\n# \n\n# **Solution 7b** (L09/09)\n# \n# The sketch below distinguish between advective and dispersive fluxes. The figure in the left is of advective process and that in the right results to dispersive flux.\n# \n# <img src=\"figs/Q7b_2019-2020.png\" alt = \"Question 7b\" class=\"bg-primary\" width =\"500px\"> \n\n# In[10]:\n\n\n#Solution 7c\n\nL_7 = 1.2 # m, col. length\nDia_7 = 5 # cm, col. diameter \nne_7 = 0.35 # (), effective porosity\nK_7 = 0.0002 # m/s, conductivity\nH_7in = 235 # m, head inlet\nH_7out = 230 # m, head outlet\nC_7 = 10 # mg/L, NaCl concentration\nal_7 = 1 # m, assumed\nC_7d = 10 # mg/L\n\n#intermediate calc.\ni_7 = (H_7in-H_7out)/L_7 # (), head gradient\nv_7dar = K_7*i_7 # m/s, darcy velocity\nv_7av = v_7dar/ne_7 # m/s, average linear velocity\n\n\n# Solution\nF_7ad = ne_7*v_7av*C_7 # mg-m/L-s, advective flux \nF_7dis = ne_7*al_7*v_7av*C_7d/L_7 # mg-m/L-s, dispersive flux \n\nprint(\"The hydraulic gradient is {0:0.4f}\".format(i_7), \"\")\nprint(\"The Darcy velocity is {0:0.4f}\".format(v_7dar), \"m/s\")\nprint(\"The average linear velocity is {0:0.4f}\".format(v_7av), \"m/s\")\nprint(\"The advective flux is {0:0.10f}\".format(F_7ad), \"mg-m/L-s\")\nprint(\"The dispersive flux is {0:0.10f}\".format(F_7dis), \"mg-m/L-s\")\n\n\n# **Q8. Sorption Isotherms** (ca. 10 pts)\n# \n# Five batch tests (different initial concentrations – see table below) were performed to determine the sorption properties of a sediment. For each batch 20 g of sediment in 30 mL of water were used. The measured equilibrium solute concentrations are also provided in the table.\n# \n# a)\tComplete the above table\t\t\t\t\t\t\t\t(ca. 3 pts.)\n# \n# b)\tPlot the results in the diagram below and draw a Henry isotherm\t\t\t(ca. 3 pts.)\n# \n# c)\tHow is retardation related to isotherm (ca. 2 points)\n# (value and unit!)\t\t(ca. 2 pts.).\n# \n# \n# \n# \n# \n\n# In[11]:\n\n\nhead = [\"Batch nr. \", \"Initial Conc. (mg/L) \", \"Equi. Conc. (mg/L)\", \"Sorbed mass (g)\", \"Sorbed mass/solid (mg/g)\" ]\nbn = np.array([1,2,3,4,5])\nC_0 = np.array([5, 10, 15, 20, 25])# mg/L, initial conc.\nC_eq = np.array([2.5, 4.9, 8, 9.8, 13.2])# mg/L, equilibrium conc.\ns2 = ips.sheet(rows=6, columns=5, row_headers=False, column_headers=head)\nips.column(0, bn, row_start=0) \nips.column(1, C_0, row_start=0)\nips.column(2, C_eq, row_start=0); \ns2\n\n\n# In[12]:\n\n\n# SOlution of Problem 10 a (T07/HP9)\n\n# Given\nv_ml = 30 # ml of water used in expt.\nv_l = v_ml/1000 # L, unit conversion\nm_s = 20 # g, solid mass used in expt.\n\nbn = np.array([1,2,3,4,5])\nC_0 = np.array([5, 10, 15, 20, 25])# mg/L, initial conc.\nC_eq = np.array([2.5, 4.9, 8, 9.8, 13.2])# mg/L, equilibrium conc.\ns_m = (C_0-C_eq)*v_l\nm_m = s_m/m_s# mg/g, mass ratio\n\n#output\nd8 = {\"Batch Nr\": bn, \"Initial Conc. (mg/L)\": C_0, \"Equi. Conc. (mg/L)\": C_eq, \"Sorbed mass (g)\": s_m, \"Sorbed mass/solid (mg/g)\" :m_m}\ndf9 = pd.DataFrame(d8); df9\n\n\n# In[13]:\n\n\n# Solution of proble 10 (b) (T07/HP9)\n# fit\nslope, intercept, r_value, p_value, std_err = stats.linregress(C_eq, m_m) # linear regression\n\n#plot and fit\nfig = plt.figure(); plt.plot(C_eq, m_m, 'bo', label=' provided data');\npred = intercept + slope*C_eq # fit line\nplt.plot(C_eq, pred, 'r', label='y={:.2E}x+{:.2f}'.format(slope,intercept)) ;\nplt.xlabel(r\"$C_{eq} $ mg/L\"); plt.ylabel(r\"$C_{a} $ mg/g\");\nplt.grid(); plt.legend(fontsize=11);  plt.text(2.2, 0.014,'$R^2 = %0.2f$' % r_value)\nplt.text(2.2, 0.012,'$C_a = K_{d}\\cdot C_{eq}$'); \n\n\n# **solution 8c**\n# (L10/13)\n# \n# The following relation relates Retardation ($R$) with linear isotherm ($K_d$)\n# \n# $$\n# R = 1+ \\frac{1-n_e}{n_e}\\rho_s K_d\n# $$\n# \n# with effective porosity $n_e$, solid density $\\rho_s$.\n\n# **Q9. Groundwater Modelling** (ca. 8 points.)\n# \n# a. Distinguish between conceptual model and mathematical model; and between analytical solution and empirical solution (ca. 4 points).\n# \n# b. Draw a conceptual model for a rectangular aquifer 100 m long and 20 m wide. Discretize the domain with 1/10 of the length length-wise and 1/5 of the width width-wise. Assure that flow in the model is from left to right direction (ca. 3 points).\n# \n# c. How is a no-flow boundary condition mathematically defined? (ca. 1 point)\n# \n# \n\n# **Solution 9a** \n# (L11/04-06)\n# \n# A model or also a _conceptual model_ is a representation, an image or a description of a real system.\n# \n# example for a real system: porous medium with water flowing through the pores (Darcy experiment)\n# \n# A _mathematical model_ provides a quantitative representation of the relevant system components, processes and impacts in the area of investigation. The quantitative representation is based on mathematical equations.\n# \n# _Analytical solution_ : These are exact mathematical expressions solving the model equations.\n# \n# _Emperical solution_ : These are solution based on experimental results. \n# \n# \t\t\t\t\t\n# \n\n# **Solution 9b** - (L14/12)\n# \n# \n# <img src=\"figs/Q9b_2019-2020.png\" alt=\"Question 9b\" class=\"bg-primary\" width = \"500px\">\n\n# **Solution 9c**\n# (L13/16)\n# \n# A no-flow boundary condition is special case of second type or Neumann boundary condition. For no flow condition head gradient is equated to zero, i.e., there is no gradient and thus no flow (water flows from high to low head). Mathematically, this is:\n# \n# $\\frac{dh}{dx} = 0 $ for no-flow along $x-$axis, with $h$ representing head.\n# \n# \n\n# Good Luck.\n", "meta": {"hexsha": "31ffb598f1a05435145edfa5f8f62706a9bd03ac", "size": 18723, "ext": "py", "lang": "Python", "max_stars_repo_path": "_build/jupyter_execute/contents/questions/GW_exam_2019_20.py", "max_stars_repo_name": "prabhasyadav/iGW-I", "max_stars_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_build/jupyter_execute/contents/questions/GW_exam_2019_20.py", "max_issues_repo_name": "prabhasyadav/iGW-I", "max_issues_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/contents/questions/GW_exam_2019_20.py", "max_forks_repo_name": "prabhasyadav/iGW-I", "max_forks_repo_head_hexsha": "eba32830f32f1109a7bee600c65832af0e7183fa", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.392733564, "max_line_length": 485, "alphanum_fraction": 0.6561982588, "include": true, "reason": "import numpy,from scipy", "num_tokens": 6305, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46879061178313897, "lm_q2_score": 0.1066905825840872, "lm_q1q2_score": 0.05001554348109375}}